diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index bd24b7c..8841086 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -34,7 +34,7 @@ jobs: id: set-matrix run: | # List of all available parsers - ALL_PARSERS="redshift postgresql cql" + ALL_PARSERS="redshift postgresql cql snowflake" # Add more parsers here as they are added to the repository # ALL_PARSERS="redshift mysql postgresql" diff --git a/snowflake/Makefile b/snowflake/Makefile new file mode 100644 index 0000000..bc34c1c --- /dev/null +++ b/snowflake/Makefile @@ -0,0 +1,7 @@ +all: build test + +build: + python3 build_id_contains_non_reserved_keywords.py && antlr -Dlanguage=Go -package snowflake -visitor -o . SnowflakeLexer.g4 SnowflakeParser.g4 + +test: + go test -v -run TestSnowflakeSQLParser diff --git a/snowflake/README.md b/snowflake/README.md new file mode 100644 index 0000000..2fd8649 --- /dev/null +++ b/snowflake/README.md @@ -0,0 +1,37 @@ +The plsql-parser is a parser for Snowflake. It is based on the [ANTLR4](https://github.com/antlr/antlr4) and use the grammar from [antlr4-grammars-plsql](https://github.com/antlr/grammars-v4/tree/master/sql/snowflake). + +## Build + +Before build, you need to install the ANTLR4. + +requirements: +- https://github.com/antlr/antlr4/blob/master/doc/getting-started.md +- https://github.com/antlr/antlr4/blob/master/doc/go-target.md + +```bash +./build.sh +``` + +## Update grammar + +### Manually change the grammar file in this project + +1. run `./build.sh` to generate the parser code. + +### From antlr4-grammars-plsql + +1. Clone the `SnowflakeLexer.g4` and `SnowflakeParser.g4` grammar files from https://github.com/antlr/grammars-v4/tree/master/sql/snowflake. +1. run `./build.sh` to generate the parser code. + +## Test the parser + +Run `TestSnowflakeSQLParser` in `parser_test.go` to test the parser. + +```bash +go test -v +``` + +## References + +- ANTLR4 Getting Started https://github.com/antlr/antlr4/blob/master/doc/getting-started.md +- ANTLR4 Go Garget https://github.com/antlr/antlr4/blob/master/doc/go-target.md \ No newline at end of file diff --git a/snowflake/SnowflakeLexer.g4 b/snowflake/SnowflakeLexer.g4 new file mode 100644 index 0000000..6a5813f --- /dev/null +++ b/snowflake/SnowflakeLexer.g4 @@ -0,0 +1,1202 @@ +/* +Snowflake Database grammar. +The MIT License (MIT). + +Copyright (c) 2022, Michał Lorek. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +lexer grammar SnowflakeLexer; + +options { caseInsensitive = true; } + +// Build id contains the non reserved keywords start. +AAD_PROVISIONER_Q: '\'AAD_PROVISIONER\''; +ABORT: 'ABORT'; +ABORT_AFTER_WAIT: 'ABORT_AFTER_WAIT'; +ABORT_DETACHED_QUERY: 'ABORT_DETACHED_QUERY'; +ABORT_STATEMENT: 'ABORT_STATEMENT'; +ABSENT: 'ABSENT'; +ABSOLUTE: 'ABSOLUTE'; +ACCESS: 'ACCESS'; +ACCOUNT: 'ACCOUNT'; +ACCOUNTADMIN: 'ACCOUNTADMIN'; +ACCOUNTS: 'ACCOUNTS'; +ACTION: 'ACTION'; +ACTIVE: 'ACTIVE'; +ADD: 'ADD'; +ADMINISTER: 'ADMINISTER'; +ADMIN_NAME: 'ADMIN_NAME'; +ADMIN_PASSWORD: 'ADMIN_PASSWORD'; +AES: 'AES'; +AFTER: 'AFTER'; +AGGREGATE: 'AGGREGATE'; +ALERT: 'ALERT'; +ALERTS: 'ALERTS'; +ALL: 'ALL'; +ALLOWED: 'ALLOWED'; +ALLOWED_ACCOUNTS: 'ALLOWED_ACCOUNTS'; +ALLOWED_DATABASES: 'ALLOWED_DATABASES'; +ALLOWED_INTEGRATION_TYPES: 'ALLOWED_INTEGRATION_TYPES'; +ALLOWED_IP_LIST: 'ALLOWED_IP_LIST'; +ALLOWED_SHARES: 'ALLOWED_SHARES'; +ALLOWED_VALUES: 'ALLOWED_VALUES'; +ALLOW_CLIENT_MFA_CACHING: 'ALLOW_CLIENT_MFA_CACHING'; +ALLOW_CONNECTIONS: 'ALLOW_CONNECTIONS'; +ALLOW_DUPLICATE: 'ALLOW_DUPLICATE'; +ALLOW_ID_TOKEN: 'ALLOW_ID_TOKEN'; +ALLOW_MULTIPLE_EVENT_LOSS: 'ALLOW_MULTIPLE_EVENT_LOSS'; +ALLOW_OVERLAPPING_EXECUTION: 'ALLOW_OVERLAPPING_EXECUTION'; +ALLOW_SINGLE_EVENT_LOSS: 'ALLOW_SINGLE_EVENT_LOSS'; +ALTER: 'ALTER'; +ALWAYS: 'ALWAYS'; +AND: 'AND'; +ANONYMOUS: 'ANONYMOUS'; +ANSI_DEFAULTS: 'ANSI_DEFAULTS'; +ANY: 'ANY'; +API: 'API'; +API_ALLOWED_PREFIXES: 'API_ALLOWED_PREFIXES'; +API_AWS_ROLE_ARN: 'API_AWS_ROLE_ARN'; +API_BLOCKED_PREFIXES: 'API_BLOCKED_PREFIXES'; +API_INTEGRATION: 'API_INTEGRATION'; +API_KEY: 'API_KEY'; +API_PROVIDER: 'API_PROVIDER'; +APPEND: 'APPEND'; +APPEND_ONLY: 'APPEND_ONLY'; +APPLICATION: 'APPLICATION'; +APPLY: 'APPLY'; +APP_NAME: 'APP_NAME'; +AS: 'AS'; +ASC: 'ASC'; +ATTACH: 'ATTACH'; +AT_KEYWORD: 'AT'; +AUTHORIZATION: 'AUTHORIZATION'; +AUTHORIZATIONS: 'AUTHORIZATIONS'; +AUTO: 'AUTO'; +AUTO_Q: '\'AUTO\''; +AUTOCOMMIT: 'AUTOCOMMIT'; +AUTOCOMMIT_API_SUPPORTED: 'AUTOCOMMIT_API_SUPPORTED'; +AUTOINCREMENT: 'AUTOINCREMENT'; +AUTO_COMPRESS: 'AUTO_COMPRESS'; +AUTO_DETECT: 'AUTO_DETECT'; +AUTO_INGEST: 'AUTO_INGEST'; +AUTO_REFRESH: 'AUTO_REFRESH'; +AUTO_RESUME: 'AUTO_RESUME'; +AUTO_SUSPEND: 'AUTO_SUSPEND'; +AVG: 'AVG'; +AVRO: 'AVRO'; +AVRO_Q: '\'AVRO\''; +AWS_KEY_ID: 'AWS_KEY_ID'; +AWS_ROLE: 'AWS_ROLE'; +AWS_SECRET_KEY: 'AWS_SECRET_KEY'; +AWS_SNS: 'AWS_SNS'; +AWS_SNS_ROLE_ARN: 'AWS_SNS_ROLE_ARN'; +AWS_SNS_TOPIC: 'AWS_SNS_TOPIC'; +AWS_SNS_TOPIC_ARN: 'AWS_SNS_TOPIC_ARN'; +AWS_TOKEN: 'AWS_TOKEN'; +AZURE: 'AZURE'; +AZURE_AD_APPLICATION_ID: 'AZURE_AD_APPLICATION_ID'; +AZURE_EVENT_GRID: 'AZURE_EVENT_GRID'; +AZURE_EVENT_GRID_TOPIC_ENDPOINT: 'AZURE_EVENT_GRID_TOPIC_ENDPOINT'; +AZURE_Q: '\'AZURE\''; +AZURE_SAS_TOKEN: 'AZURE_SAS_TOKEN'; +AZURE_STORAGE_QUEUE_PRIMARY_URI: 'AZURE_STORAGE_QUEUE_PRIMARY_URI'; +AZURE_TENANT_ID: 'AZURE_TENANT_ID'; +BASE64: 'BASE64'; +BEFORE: 'BEFORE'; +BEGIN: 'BEGIN'; +BERNOULLI: 'BERNOULLI'; +BETWEEN: 'BETWEEN'; +BINARY_AS_TEXT: 'BINARY_AS_TEXT'; +BINARY_CHECKSUM: 'BINARY_CHECKSUM'; +BINARY_FORMAT: 'BINARY_FORMAT'; +BINARY_INPUT_FORMAT: 'BINARY_INPUT_FORMAT'; +BINARY_OUTPUT_FORMAT: 'BINARY_OUTPUT_FORMAT'; +BINDING: 'BINDING'; +BLOCK: 'BLOCK'; +BLOCKED_IP_LIST: 'BLOCKED_IP_LIST'; +BLOCKED_ROLES_LIST: 'BLOCKED_ROLES_LIST'; +BODY: 'BODY'; +BOTH_Q: '\'BOTH\''; +BROTLI: 'BROTLI'; +BUSINESS_CRITICAL: 'BUSINESS_CRITICAL'; +BY: 'BY'; +BZ2: 'BZ2'; +CACHE: 'CACHE'; +CALL: 'CALL'; +CALLED: 'CALLED'; +CALLER: 'CALLER'; +CASCADE: 'CASCADE'; +CASE: 'CASE'; +CASE_INSENSITIVE: 'CASE_INSENSITIVE'; +CASE_SENSITIVE: 'CASE_SENSITIVE'; +CAST: 'CAST'; +CATCH: 'CATCH'; +CERTIFICATE: 'CERTIFICATE'; +CHANGE: 'CHANGE'; +CHANGES: 'CHANGES'; +CHANGETABLE: 'CHANGETABLE'; +CHANGE_RETENTION: 'CHANGE_RETENTION'; +CHANGE_TRACKING: 'CHANGE_TRACKING'; +CHAR: 'CHAR'; +CHARACTER: 'CHARACTER'; +CHARINDEX: 'CHARINDEX'; +CHECK: 'CHECK'; +CHECKSUM: 'CHECKSUM'; +CHECKSUM_AGG: 'CHECKSUM_AGG'; +CHECK_EXPIRATION: 'CHECK_EXPIRATION'; +CHECK_POLICY: 'CHECK_POLICY'; +CLASSIFIER_FUNCTION: 'CLASSIFIER_FUNCTION'; +CLEANUP: 'CLEANUP'; +CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS: 'CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS'; +CLIENT_ENCRYPTION_KEY_SIZE: 'CLIENT_ENCRYPTION_KEY_SIZE'; +CLIENT_MEMORY_LIMIT: 'CLIENT_MEMORY_LIMIT'; +CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX: 'CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX'; +CLIENT_METADATA_USE_SESSION_DATABASE: 'CLIENT_METADATA_USE_SESSION_DATABASE'; +CLIENT_PREFETCH_THREADS: 'CLIENT_PREFETCH_THREADS'; +CLIENT_RESULT_CHUNK_SIZE: 'CLIENT_RESULT_CHUNK_SIZE'; +CLIENT_RESULT_COLUMN_CASE_INSENSITIVE: 'CLIENT_RESULT_COLUMN_CASE_INSENSITIVE'; +CLIENT_SESSION_KEEP_ALIVE: 'CLIENT_SESSION_KEEP_ALIVE'; +CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY: 'CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY'; +CLIENT_TIMESTAMP_TYPE_MAPPING: 'CLIENT_TIMESTAMP_TYPE_MAPPING'; +CLONE: 'CLONE'; +CLOSE: 'CLOSE'; +CLUSTER: 'CLUSTER'; +CLUSTERED: 'CLUSTERED'; +CLUSTERING: 'CLUSTERING'; +COALESCE: 'COALESCE'; +COLLATE: 'COLLATE'; +COLLECTION: 'COLLECTION'; +COLUMN: 'COLUMN'; +COLUMNS: 'COLUMNS'; +COL_LENGTH: 'COL_LENGTH'; +COL_NAME: 'COL_NAME'; +COMMENT: 'COMMENT'; +COMMIT: 'COMMIT'; +COMMITTED: 'COMMITTED'; +COMPRESS: 'COMPRESS'; +COMPRESSION: 'COMPRESSION'; +CONCAT: 'CONCAT'; +CONCAT_NULL_YIELDS_NULL: 'CONCAT_NULL_YIELDS_NULL'; +CONCAT_WS: 'CONCAT_WS'; +CONDITION: 'CONDITION'; +CONFIGURATION: 'CONFIGURATION'; +CONNECT: 'CONNECT'; +CONNECTION: 'CONNECTION'; +CONNECTIONS: 'CONNECTIONS'; +CONSTRAINT: 'CONSTRAINT'; +CONTAINMENT: 'CONTAINMENT'; +CONTAINS: 'CONTAINS'; +CONTENT: 'CONTENT'; +CONTEXT: 'CONTEXT'; +CONTEXT_HEADERS: 'CONTEXT_HEADERS'; +CONTEXT_INFO: 'CONTEXT_INFO'; +CONTINUE: 'CONTINUE'; +CONTROL: 'CONTROL'; +CONVERSATION: 'CONVERSATION'; +COOKIE: 'COOKIE'; +COPY: 'COPY'; +COPY_ONLY: 'COPY_ONLY'; +COPY_OPTIONS_: 'COPY_OPTIONS'; +COUNT: 'COUNT'; +COUNT_BIG: 'COUNT_BIG'; +CREATE: 'CREATE'; +CREDENTIALS: 'CREDENTIALS'; +CREDIT_QUOTA: 'CREDIT_QUOTA'; +CROSS: 'CROSS'; +CSV: 'CSV'; +CSV_Q: '\'CSV\''; +CUBE: 'CUBE'; +CUME_DIST: 'CUME_DIST'; +CURRENT: 'CURRENT'; +CURRENT_DATE: 'CURRENT_DATE'; +CURRENT_TIME: 'CURRENT_TIME'; +CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'; +CURRENT_USER: 'CURRENT_USER'; +CURSOR: 'CURSOR'; +CUSTOM: 'CUSTOM'; +DAILY: 'DAILY'; +DATA: 'DATA'; +DATABASE: 'DATABASE'; +DATABASES: 'DATABASES'; +DATA_RETENTION_TIME_IN_DAYS: 'DATA_RETENTION_TIME_IN_DAYS'; +DATEADD: 'DATEADD'; +DATEDIFF: 'DATEDIFF'; +DATENAME: 'DATENAME'; +DATEPART: 'DATEPART'; +DATE_FORMAT: 'DATE_FORMAT'; +DATE_INPUT_FORMAT: 'DATE_INPUT_FORMAT'; +DATE_OUTPUT_FORMAT: 'DATE_OUTPUT_FORMAT'; +DATE_PART: 'DATE_PART'; +DAYS: 'DAYS'; +DAYS_TO_EXPIRY: 'DAYS_TO_EXPIRY'; +DECLARE: 'DECLARE'; +DEFAULT: 'DEFAULT'; +DEFAULT_DDL_COLLATION_: 'DEFAULT_DDL_COLLATION'; +DEFAULT_NAMESPACE: 'DEFAULT_NAMESPACE'; +DEFAULT_ROLE: 'DEFAULT_ROLE'; +DEFAULT_WAREHOUSE: 'DEFAULT_WAREHOUSE'; +DEFERRABLE: 'DEFERRABLE'; +DEFERRED: 'DEFERRED'; +DEFINE: 'DEFINE'; +DEFINITION: 'DEFINITION'; +DEFLATE: 'DEFLATE'; +DELEGATED: 'DELEGATED'; +DELETE: 'DELETE'; +DELTA: 'DELTA'; +DENSE_RANK: 'DENSE_RANK'; +DESC: 'DESC'; +DESCRIBE: 'DESCRIBE'; +DIRECTION: 'DIRECTION'; +DIRECTORY: 'DIRECTORY'; +DISABLE: 'DISABLE'; +DISABLED: 'DISABLED'; +DISABLE_AUTO_CONVERT: 'DISABLE_AUTO_CONVERT'; +DISABLE_SNOWFLAKE_DATA: 'DISABLE_SNOWFLAKE_DATA'; +DISK: 'DISK'; +DISPLAY_NAME: 'DISPLAY_NAME'; +DISTINCT: 'DISTINCT'; +DO: 'DO'; +DOWNSTREAM: 'DOWNSTREAM'; +DOUBLE: 'DOUBLE'; +DROP: 'DROP'; +DYNAMIC: 'DYNAMIC'; +ECONOMY: 'ECONOMY'; +EDITION: 'EDITION'; +ELSE: 'ELSE'; +EMAIL: 'EMAIL'; +EMPTY_: 'EMPTY'; +EMPTY_FIELD_AS_NULL: 'EMPTY_FIELD_AS_NULL'; +ENABLE: 'ENABLE'; +ENABLED: 'ENABLED'; +ENABLE_FOR_PRIVILEGE: 'ENABLE_FOR_PRIVILEGE'; +ENABLE_INTERNAL_STAGES_PRIVATELINK: 'ENABLE_INTERNAL_STAGES_PRIVATELINK'; +ENABLE_OCTAL: 'ENABLE_OCTAL'; +ENABLE_QUERY_ACCELERATION: 'ENABLE_QUERY_ACCELERATION'; +ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION: 'ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION'; +ENCODING: 'ENCODING'; +ENCRYPTION: 'ENCRYPTION'; +END: 'END'; +ENDPOINT: 'ENDPOINT'; +END_TIMESTAMP: 'END_TIMESTAMP'; +ENFORCED: 'ENFORCED'; +ENFORCE_LENGTH: 'ENFORCE_LENGTH'; +ENFORCE_SESSION_POLICY: 'ENFORCE_SESSION_POLICY'; +ENTERPRISE: 'ENTERPRISE'; +EQUALITY: 'EQUALITY'; +ERROR_INTEGRATION: 'ERROR_INTEGRATION'; +ERROR_ON_COLUMN_COUNT_MISMATCH: 'ERROR_ON_COLUMN_COUNT_MISMATCH'; +ERROR_ON_NONDETERMINISTIC_MERGE: 'ERROR_ON_NONDETERMINISTIC_MERGE'; +ERROR_ON_NONDETERMINISTIC_UPDATE: 'ERROR_ON_NONDETERMINISTIC_UPDATE'; +ESCAPE: 'ESCAPE'; +ESCAPE_UNENCLOSED_FIELD: 'ESCAPE_UNENCLOSED_FIELD'; +EXCEPT: 'EXCEPT'; +EXCHANGE: 'EXCHANGE'; +EXECUTE: 'EXEC' 'UTE'?; +EXECUTION: 'EXECUTION'; +EXIST: 'EXIST'; +EXISTS: 'EXISTS'; +EXIT: 'EXIT'; +EXPAND: 'EXPAND'; +EXPIRY_DATE: 'EXPIRY_DATE'; +EXPLAIN: 'EXPLAIN'; +EXPLICIT: 'EXPLICIT'; +EXTERNAL: 'EXTERNAL'; +EXTERNAL_OAUTH: 'EXTERNAL_OAUTH'; +EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST: 'EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST'; +EXTERNAL_OAUTH_ALLOWED_ROLES_LIST: 'EXTERNAL_OAUTH_ALLOWED_ROLES_LIST'; +EXTERNAL_OAUTH_ANY_ROLE_MODE: 'EXTERNAL_OAUTH_ANY_ROLE_MODE'; +EXTERNAL_OAUTH_AUDIENCE_LIST: 'EXTERNAL_OAUTH_AUDIENCE_LIST'; +EXTERNAL_OAUTH_BLOCKED_ROLES_LIST: 'EXTERNAL_OAUTH_BLOCKED_ROLES_LIST'; +EXTERNAL_OAUTH_ISSUER: 'EXTERNAL_OAUTH_ISSUER'; +EXTERNAL_OAUTH_JWS_KEYS_URL: 'EXTERNAL_OAUTH_JWS_KEYS_URL'; +EXTERNAL_OAUTH_RSA_PUBLIC_KEY: 'EXTERNAL_OAUTH_RSA_PUBLIC_KEY'; +EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2: 'EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2'; +EXTERNAL_OAUTH_SCOPE_DELIMITER: 'EXTERNAL_OAUTH_SCOPE_DELIMITER'; +EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE: 'EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE'; +EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM: 'EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM'; +EXTERNAL_OAUTH_TYPE: 'EXTERNAL_OAUTH_TYPE'; +EXTERNAL_STAGE: 'EXTERNAL_STAGE'; +FAILOVER: 'FAILOVER'; +FAILOVER_MODE: 'FAILOVER_MODE'; +FAIL_OPERATION: 'FAIL_OPERATION'; +FALSE: 'FALSE'; +FETCH: 'FETCH'; +FIELD_DELIMITER: 'FIELD_DELIMITER'; +FIELD_OPTIONALLY_ENCLOSED_BY: 'FIELD_OPTIONALLY_ENCLOSED_BY'; +FILE: 'FILE'; +FILES: 'FILES'; +FILE_EXTENSION: 'FILE_EXTENSION'; +FILE_FORMAT: 'FILE_FORMAT'; +FILTER: 'FILTER'; +FIRST: 'FIRST'; +FIRST_NAME: 'FIRST_NAME'; +FLATTEN: 'FLATTEN'; +FOR: 'FOR'; +FORCE: 'FORCE'; +FOREIGN: 'FOREIGN'; +FORMAT: 'FORMAT'; +FORMATS: 'FORMATS'; +FORMAT_NAME: 'FORMAT_NAME'; +FREQUENCY: 'FREQUENCY'; +FROM: 'FROM'; +FULL: 'FULL'; +FUNCTION: 'FUNCTION'; +FUNCTIONS: 'FUNCTIONS'; +FUTURE: 'FUTURE'; +GCP_PUBSUB: 'GCP_PUBSUB'; +GCP_PUBSUB_SUBSCRIPTION_NAME: 'GCP_PUBSUB_SUBSCRIPTION_NAME'; +GCP_PUBSUB_TOPIC_NAME: 'GCP_PUBSUB_TOPIC_NAME'; +GCS: 'GCS'; +GENERIC_Q: '\'GENERIC\''; +GENERIC_SCIM_PROVISIONER_Q: '\'GENERIC_SCIM_PROVISIONER\''; +GEO: 'GEO'; +GEOGRAPHY_OUTPUT_FORMAT: 'GEOGRAPHY_OUTPUT_FORMAT'; +GEOMETRY_OUTPUT_FORMAT: 'GEOMETRY_OUTPUT_FORMAT'; +GET: 'GET'; +GET_FILESTREAM_TRANSACTION_CONTEXT: 'GET_FILESTREAM_TRANSACTION_CONTEXT'; +GLOBAL: 'GLOBAL'; +GOOGLE_AUDIENCE: 'GOOGLE_AUDIENCE'; +GOTO: 'GOTO'; +GRANT: 'GRANT'; +GRANTS: 'GRANTS'; +GROUP: 'GROUP'; +GROUPING: 'GROUPING'; +GROUPING_ID: 'GROUPING_ID'; +GROUPS: 'GROUPS'; +GZIP: 'GZIP'; +HAVING: 'HAVING'; +HEADER: 'HEADER'; +HEADERS: 'HEADERS'; +HEX: 'HEX'; +HIERARCHYID: 'HIERARCHYID'; +HIGH: 'HIGH'; +HISTORY: 'HISTORY'; +HOURS: 'HOURS'; +IDENTITY: 'IDENTITY'; +IF: 'IF'; +IFF: 'IFF'; +IFNULL: 'IFNULL'; +IGNORE: 'IGNORE'; +IGNORE_CONSTRAINTS: 'IGNORE_CONSTRAINTS'; +IGNORE_DUP_KEY: 'IGNORE_DUP_KEY'; +IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX: 'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX'; +IGNORE_TRIGGERS: 'IGNORE_TRIGGERS'; +IGNORE_UTF8_ERRORS: 'IGNORE_UTF8_ERRORS'; +ILIKE: 'ILIKE'; +IMMEDIATE: 'IMMEDIATE'; +IMMEDIATELY: 'IMMEDIATELY'; +IMMUTABLE: 'IMMUTABLE'; +IMPLICIT: 'IMPLICIT'; +IMPORT: 'IMPORT'; +IMPORTED: 'IMPORTED'; +IN: 'IN'; +INCREMENT: 'INCREMENT'; +INDEX: 'INDEX'; +INFORMATION: 'INFORMATION'; +INIT: 'INIT'; +INITIALLY: 'INITIALLY'; +INITIALLY_SUSPENDED: 'INITIALLY_SUSPENDED'; +INITIAL_REPLICATION_SIZE_LIMIT_IN_TB: 'INITIAL_REPLICATION_SIZE_LIMIT_IN_TB'; +INNER: 'INNER'; +INPUT: 'INPUT'; +INSERT: 'INSERT'; +INSERT_ONLY: 'INSERT_ONLY'; +INSTEAD: 'INSTEAD'; +INT: 'INT'; +INTEGRATION: 'INTEGRATION'; +INTEGRATIONS: 'INTEGRATIONS'; +INTERSECT: 'INTERSECT'; +INTO: 'INTO'; +IS: 'IS'; +ISNULL: 'ISNULL'; +ISNUMERIC: 'ISNUMERIC'; +ISOLATION: 'ISOLATION'; +JAVASCRIPT: 'JAVASCRIPT'; +JDBC_TREAT_DECIMAL_AS_INT: 'JDBC_TREAT_DECIMAL_AS_INT'; +JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC: 'JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC'; +JDBC_USE_SESSION_TIMEZONE: 'JDBC_USE_SESSION_TIMEZONE'; +JOIN: 'JOIN'; +JSON: 'JSON'; +JSON_Q: '\'JSON\''; +JSON_INDENT: 'JSON_INDENT'; +JS_TREAT_INTEGER_AS_BIGINT: 'JS_TREAT_INTEGER_AS_BIGINT'; +KB: 'KB'; +KEEP: 'KEEP'; +KEY: 'KEY'; +KEYS: 'KEYS'; +KEYSET: 'KEYSET'; +KMS_KEY_ID: 'KMS_KEY_ID'; +LAG: 'LAG'; +LANGUAGE: 'LANGUAGE'; +LARGE: 'LARGE'; +LAST: 'LAST'; +LAST_NAME: 'LAST_NAME'; +LAST_QUERY_ID: 'LAST_QUERY_ID'; +LAST_VALUE: 'LAST_VALUE'; +LATERAL: 'LATERAL'; +LEAD: 'LEAD'; +LEFT: 'LEFT'; +LEN: 'LEN'; +LENGTH: 'LENGTH'; +LEVEL: 'LEVEL'; +LIKE: 'LIKE'; +LIMIT: 'LIMIT'; +LINENO: 'LINENO'; +LIST: 'LIST'; +LISTENER_IP: 'LISTENER_IP'; +LISTENER_PORT: 'LISTENER_PORT'; +LISTING: 'LISTING'; +LOAD: 'LOAD'; +LOCAL: 'LOCAL'; +LOCAL_SERVICE_NAME: 'LOCAL_SERVICE_NAME'; +LOCATION: 'LOCATION'; +LOCKS: 'LOCKS'; +LOCK_TIMEOUT: 'LOCK_TIMEOUT'; +LOG: 'LOG'; +LOGIN: 'LOGIN'; +LOGIN_NAME: 'LOGIN_NAME'; +LOOKER: 'LOOKER'; +LOW: 'LOW'; +LOWER: 'LOWER'; +LTRIM: 'LTRIM'; +LZO: 'LZO'; +MANAGE: 'MANAGE'; +MANAGED: 'MANAGED'; +MASK: 'MASK'; +MASKED: 'MASKED'; +MASKING: 'MASKING'; +MASTER: 'MASTER'; +MASTER_KEY: 'MASTER_KEY'; +MATCH: 'MATCH'; +MATCHED: 'MATCHED'; +MATCHES: 'MATCHES'; +MATCH_BY_COLUMN_NAME: 'MATCH_BY_COLUMN_NAME'; +MATCH_RECOGNIZE: 'MATCH_RECOGNIZE'; +MATERIALIZED: 'MATERIALIZED'; +MAX_BATCH_ROWS: 'MAX_BATCH_ROWS'; +MAX_CLUSTER_COUNT: 'MAX_CLUSTER_COUNT'; +MAX_CONCURRENCY_LEVEL: 'MAX_CONCURRENCY_LEVEL'; +MAX_DATA_EXTENSION_TIME_IN_DAYS: 'MAX_DATA_EXTENSION_TIME_IN_DAYS'; +MAX_SIZE: 'MAX_SIZE'; +MEASURES: 'MEASURES'; +MEDIUM: 'MEDIUM'; +MEMOIZABLE: 'MEMOIZABLE'; +MERGE: 'MERGE'; +MIDDLE_NAME: 'MIDDLE_NAME'; +MIN: 'MIN'; +MINS_TO_BYPASS_MFA: 'MINS_TO_BYPASS_MFA'; +MINS_TO_UNLOCK: 'MINS_TO_UNLOCK'; +MINUS_: 'MINUS'; +MINUTES: 'MINUTES'; +MIN_CLUSTER_COUNT: 'MIN_CLUSTER_COUNT'; +MIN_DATA_RETENTION_TIME_IN_DAYS: 'MIN_DATA_RETENTION_TIME_IN_DAYS'; +MODE: 'MODE'; +MODIFIED_AFTER: 'MODIFIED_AFTER'; +MODIFY: 'MODIFY'; +MONITOR: 'MONITOR'; +MONITORS: 'MONITORS'; +MONTHLY: 'MONTHLY'; +MOVE: 'MOVE'; +MULTI_STATEMENT_COUNT: 'MULTI_STATEMENT_COUNT'; +MULTI_USER: 'MULTI_USER'; +MUST_CHANGE: 'MUST_CHANGE'; +MUST_CHANGE_PASSWORD: 'MUST_CHANGE_PASSWORD'; +NAME: 'NAME'; +NATURAL: 'NATURAL'; +NCHAR: 'NCHAR'; +NESTED_TRIGGERS: 'NESTED_TRIGGERS'; +NETWORK: 'NETWORK'; +NETWORK_POLICY: 'NETWORK_POLICY'; +NEVER: 'NEVER'; +NEWID: 'NEWID'; +NEWNAME: 'NEWNAME'; +NEWSEQUENTIALID: 'NEWSEQUENTIALID'; +NEW_ACCOUNT: 'NEW_ACCOUNT'; +NEW_BROKER: 'NEW_BROKER'; +NEW_PASSWORD: 'NEW_PASSWORD'; +NEXT: 'NEXT'; +NEXTVAL: 'NEXTVAL'; +NO: 'NO'; +NONE: 'NONE'; +NONE_Q: '\'NONE\''; +NORELY: 'NORELY'; +NOT: 'NOT'; +NOTIFICATION: 'NOTIFICATION'; +NOTIFICATIONS: 'NOTIFICATIONS'; +NOTIFICATION_INTEGRATION: 'NOTIFICATION_INTEGRATION'; +NOTIFICATION_PROVIDER: 'NOTIFICATION_PROVIDER'; +NOTIFY: 'NOTIFY'; +NOTIFY_USERS: 'NOTIFY_USERS'; +NOVALIDATE: 'NOVALIDATE'; +NTILE: 'NTILE'; +NULLIF: 'NULLIF'; +NULLS: 'NULLS'; +NULL_: 'NULL'; +NULL_IF: 'NULL_IF'; +NUMANODE: 'NUMANODE'; +NUMBER: 'NUMBER'; +NUMERIC_ROUNDABORT: 'NUMERIC_ROUNDABORT'; +NVL: 'NVL'; +OAUTH: 'OAUTH'; +OAUTH_ALLOW_NON_TLS_REDIRECT_URI: 'OAUTH_ALLOW_NON_TLS_REDIRECT_URI'; +OAUTH_CLIENT: 'OAUTH_CLIENT'; +OAUTH_CLIENT_RSA_PUBLIC_KEY: 'OAUTH_CLIENT_RSA_PUBLIC_KEY'; +OAUTH_CLIENT_RSA_PUBLIC_KEY_2: 'OAUTH_CLIENT_RSA_PUBLIC_KEY_2'; +OAUTH_ENFORCE_PKCE: 'OAUTH_ENFORCE_PKCE'; +OAUTH_ISSUE_REFRESH_TOKENS: 'OAUTH_ISSUE_REFRESH_TOKENS'; +OAUTH_REDIRECT_URI: 'OAUTH_REDIRECT_URI'; +OAUTH_REFRESH_TOKEN_VALIDITY: 'OAUTH_REFRESH_TOKEN_VALIDITY'; +OAUTH_USE_SECONDARY_ROLES: 'OAUTH_USE_SECONDARY_ROLES'; +OBJECT: 'OBJECT'; +OBJECT_Q: '\'OBJECT\''; +OBJECTS: 'OBJECTS'; +OBJECT_TYPES: 'OBJECT_TYPES'; +OF: 'OF'; +OFF: 'OFF'; +OFFSET: 'OFFSET'; +OFFSETS: 'OFFSETS'; +OKTA: 'OKTA'; +OKTA_PROVISIONER_Q: '\'OKTA_PROVISIONER\''; +OKTA_Q: '\'OKTA\''; +OLD: 'OLD'; +OLD_ACCOUNT: 'OLD_ACCOUNT'; +OLD_PASSWORD: 'OLD_PASSWORD'; +OMIT: 'OMIT'; +ON: 'ON'; +ONE: 'ONE'; +ONLINE: 'ONLINE'; +ONLY: 'ONLY'; +ON_ERROR: 'ON_ERROR'; +ON_FAILURE: 'ON_FAILURE'; +OPEN: 'OPEN'; +OPERATE: 'OPERATE'; +OPERATIONS: 'OPERATIONS'; +OPTIMIZATION: 'OPTIMIZATION'; +OPTION: 'OPTION'; +OR: 'OR'; +ORC: 'ORC'; +ORC_Q: '\'ORC\''; +ORDER: 'ORDER'; +ORGADMIN: 'ORGADMIN'; +ORGANIZATION: 'ORGANIZATION'; +OUTBOUND: 'OUTBOUND'; +OUTER: 'OUTER'; +OVER: 'OVER'; +OVERRIDE: 'OVERRIDE'; +OVERWRITE: 'OVERWRITE'; +OWNER: 'OWNER'; +OWNERSHIP: 'OWNERSHIP'; +PAGE: 'PAGE'; +PARALLEL: 'PARALLEL'; +PARAMETERS: 'PARAMETERS'; +PARAM_NODE: 'PARAM_NODE'; +PARQUET: 'PARQUET'; +PARQUET_Q: '\'PARQUET\''; +PARTIAL: 'PARTIAL'; +PARTITION: 'PARTITION'; +PARTITIONS: 'PARTITIONS'; +PARTITION_TYPE: 'PARTITION_TYPE'; +PASSWORD: 'PASSWORD'; +PAST: 'PAST'; +PATH_: 'PATH'; +PATTERN: 'PATTERN'; +PER: 'PER'; +PERCENT: 'PERCENT'; +PERCENTILE_CONT: 'PERCENTILE_CONT'; +PERCENTILE_DISC: 'PERCENTILE_DISC'; +PERCENT_RANK: 'PERCENT_RANK'; +PERIODIC_DATA_REKEYING: 'PERIODIC_DATA_REKEYING'; +PERMISSION_SET: 'PERMISSION_SET'; +PERSISTED: 'PERSISTED'; +PERSIST_SAMPLE_PERCENT: 'PERSIST_SAMPLE_PERCENT'; +PING_FEDERATE: 'PING_FEDERATE'; +PIPE: 'PIPE'; +PIPES: 'PIPES'; +PIPE_EXECUTION_PAUSED: 'PIPE_EXECUTION_PAUSED'; +PIVOT: 'PIVOT'; +PLAN: 'PLAN'; +PLATFORM: 'PLATFORM'; +POLICIES: 'POLICIES'; +POLICY: 'POLICY'; +POOL: 'POOL'; +PORT: 'PORT'; +PRECEDING: 'PRECEDING'; +PRECISION: 'PRECISION'; +PREDICATE: 'PREDICATE'; +PREFIX: 'PREFIX'; +PRESERVE_SPACE: 'PRESERVE_SPACE'; +PREVENT_UNLOAD_TO_INLINE_URL: 'PREVENT_UNLOAD_TO_INLINE_URL'; +PREVENT_UNLOAD_TO_INTERNAL_STAGES: 'PREVENT_UNLOAD_TO_INTERNAL_STAGES'; +PRE_AUTHORIZED_ROLES_LIST: 'PRE_AUTHORIZED_ROLES_LIST'; +PRIMARY: 'PRIMARY'; +PRIMARY_ROLE: 'PRIMARY_ROLE'; +PRIOR: 'PRIOR'; +PRIORITY: 'PRIORITY'; +PRIORITY_LEVEL: 'PRIORITY_LEVEL'; +PRIVATE: 'PRIVATE'; +PRIVATE_KEY: 'PRIVATE_KEY'; +PRIVILEGES: 'PRIVILEGES'; +PROC: 'PROC'; +PROCEDURE: 'PROCEDURE'; +PROCEDURES: 'PROCEDURES'; +PROCEDURE_NAME: 'PROCEDURE_NAME'; +PROCESS: 'PROCESS'; +PROFILE: 'PROFILE'; +PROPERTY: 'PROPERTY'; +PROVIDER: 'PROVIDER'; +PROVIDER_KEY_NAME: 'PROVIDER_KEY_NAME'; +PUBLIC: 'PUBLIC'; +PURGE: 'PURGE'; +PUT: 'PUT'; +PYTHON: 'PYTHON'; +QUALIFY: 'QUALIFY'; +QUERIES: 'QUERIES'; +QUERY: 'QUERY'; +QUERY_ACCELERATION_MAX_SCALE_FACTOR: 'QUERY_ACCELERATION_MAX_SCALE_FACTOR'; +QUERY_TAG: 'QUERY_TAG'; +QUEUE: 'QUEUE'; +QUOTED_IDENTIFIERS_IGNORE_CASE: 'QUOTED_IDENTIFIERS_IGNORE_CASE'; +RANGE: 'RANGE'; +RANK: 'RANK'; +RAW_DEFLATE: 'RAW_DEFLATE'; +READ: 'READ'; +READER: 'READER'; +READONLY: 'READONLY'; +READPAST: 'READPAST'; +READTEXT: 'READTEXT'; +READWRITE: 'READWRITE'; +READ_COMMITTED_SNAPSHOT: 'READ_COMMITTED_SNAPSHOT'; +READ_ONLY: 'READ_ONLY'; +READ_ONLY_ROUTING_LIST: 'READ_ONLY_ROUTING_LIST'; +READ_WRITE: 'READ_WRITE'; +REBUILD: 'REBUILD'; +RECEIVE: 'RECEIVE'; +RECLUSTER: 'RECLUSTER'; +RECOMPILE: 'RECOMPILE'; +RECONFIGURE: 'RECONFIGURE'; +RECORD_DELIMITER: 'RECORD_DELIMITER'; +RECOVERY: 'RECOVERY'; +RECURSIVE: 'RECURSIVE'; +RECURSIVE_TRIGGERS: 'RECURSIVE_TRIGGERS'; +REFERENCES: 'REFERENCES'; +REFERENCE_USAGE: 'REFERENCE_USAGE'; +REFRESH: 'REFRESH'; +REFRESH_ON_CREATE: 'REFRESH_ON_CREATE'; +REGION: 'REGION'; +REGIONS: 'REGIONS'; +REGION_GROUP: 'REGION_GROUP'; +RELATIVE: 'RELATIVE'; +RELY: 'RELY'; +REMOTE: 'REMOTE'; +REMOTE_PROC_TRANSACTIONS: 'REMOTE_PROC_TRANSACTIONS'; +REMOTE_SERVICE_NAME: 'REMOTE_SERVICE_NAME'; +REMOVE: 'REMOVE'; +RENAME: 'RENAME'; +REPEATABLE: 'REPEATABLE'; +REPLACE: 'REPLACE'; +REPLACE_INVALID_CHARACTERS: 'REPLACE_INVALID_CHARACTERS'; +REPLICA: 'REPLICA'; +REPLICATION: 'REPLICATION'; +REPLICATION_SCHEDULE: 'REPLICATION_SCHEDULE'; +REQUEST_TRANSLATOR: 'REQUEST_TRANSLATOR'; +REQUIRED: 'REQUIRED'; +REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION: 'REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION'; +REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION: 'REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION'; +RESET: 'RESET'; +RESOURCE: 'RESOURCE'; +RESOURCES: 'RESOURCES'; +RESOURCE_MONITOR: 'RESOURCE_MONITOR'; +RESPONSE_TRANSLATOR: 'RESPONSE_TRANSLATOR'; +RESTART: 'RESTART'; +RESTORE: 'RESTORE'; +RESTRICT: 'RESTRICT'; +RESTRICTIONS: 'RESTRICTIONS'; +RESULT: 'RESULT'; +RESUME: 'RESUME'; +RETAINDAYS: 'RETAINDAYS'; +RETURN: 'RETURN'; +RETURNS: 'RETURNS'; +RETURN_ALL_ERRORS: 'RETURN_ALL_ERRORS'; +RETURN_ERRORS: 'RETURN_ERRORS'; +RETURN_FAILED_ONLY: 'RETURN_FAILED_ONLY'; +RETURN_N_ROWS: 'RETURN_' DEC_DIGIT+ '_ROWS'; +RETURN_ROWS: 'RETURN_ROWS'; +REVERSE: 'REVERSE'; +REVERT: 'REVERT'; +REVOKE: 'REVOKE'; +REWIND: 'REWIND'; +RIGHT: 'RIGHT'; +RLIKE: 'RLIKE'; +ROLE: 'ROLE'; +ROLES: 'ROLES'; +ROLLBACK: 'ROLLBACK'; +ROLLUP: 'ROLLUP'; +ROOT: 'ROOT'; +ROW: 'ROW'; +ROWCOUNT: 'ROWCOUNT'; +ROWGUID: 'ROWGUID'; +ROWLOCK: 'ROWLOCK'; +ROWS: 'ROWS'; +ROWS_PER_RESULTSET: 'ROWS_PER_RESULTSET'; +ROW_NUMBER: 'ROW_NUMBER'; +RSA_PUBLIC_KEY: 'RSA_PUBLIC_KEY'; +RSA_PUBLIC_KEY_2: 'RSA_PUBLIC_KEY_2'; +RTRIM: 'RTRIM'; +RUN_AS_ROLE: 'RUN_AS_ROLE'; +S3: '\'S3\''; +SAFE: 'SAFE'; +SAFETY: 'SAFETY'; +SAML2: 'SAML2'; +SAML2_ENABLE_SP_INITIATED: 'SAML2_ENABLE_SP_INITIATED'; +SAML2_FORCE_AUTHN: 'SAML2_FORCE_AUTHN'; +SAML2_ISSUER: 'SAML2_ISSUER'; +SAML2_POST_LOGOUT_REDIRECT_URL: 'SAML2_POST_LOGOUT_REDIRECT_URL'; +SAML2_PROVIDER: 'SAML2_PROVIDER'; +SAML2_REQUESTED_NAMEID_FORMAT: 'SAML2_REQUESTED_NAMEID_FORMAT'; +SAML2_SIGN_REQUEST: 'SAML2_SIGN_REQUEST'; +SAML2_SNOWFLAKE_ACS_URL: 'SAML2_SNOWFLAKE_ACS_URL'; +SAML2_SNOWFLAKE_ISSUER_URL: 'SAML2_SNOWFLAKE_ISSUER_URL'; +SAML2_SNOWFLAKE_X509_CERT: 'SAML2_SNOWFLAKE_X509_CERT'; +SAML2_SP_INITIATED_LOGIN_PAGE_LABEL: 'SAML2_SP_INITIATED_LOGIN_PAGE_LABEL'; +SAML2_SSO_URL: 'SAML2_SSO_URL'; +SAML2_X509_CERT: 'SAML2_X509_CERT'; +SAML_IDENTITY_PROVIDER: 'SAML_IDENTITY_PROVIDER'; +SAMPLE: 'SAMPLE'; +SAVE_OLD_URL: 'SAVE_OLD_URL'; +SCALING_POLICY: 'SCALING_POLICY'; +SCHEDULE: 'SCHEDULE'; +SCHEDULER: 'SCHEDULER'; +SCHEMA: 'SCHEMA'; +SCHEMAS: 'SCHEMAS'; +SCHEME: 'SCHEME'; +SCIM: 'SCIM'; +SCIM_CLIENT: 'SCIM_CLIENT'; +SCRIPT: 'SCRIPT'; +SEARCH: 'SEARCH'; +SECONDARY: 'SECONDARY'; +SECONDARY_ONLY: 'SECONDARY_ONLY'; +SECONDARY_ROLE: 'SECONDARY_ROLE'; +SECONDS: 'SECONDS'; +SECRET: 'SECRET'; +SECURE: 'SECURE'; +SECURITY: 'SECURITY'; +SECURITYADMIN: 'SECURITYADMIN'; +SEED: 'SEED'; +SELECT: 'SELECT'; +SELF: 'SELF'; +SEQUENCE: 'SEQUENCE'; +SEQUENCES: 'SEQUENCES'; +SERVER: 'SERVER'; +SERVICE: 'SERVICE'; +SESSION: 'SESSION'; +SESSION_IDLE_TIMEOUT_MINS: 'SESSION_IDLE_TIMEOUT_MINS'; +SESSION_POLICY: 'SESSION_POLICY'; +SESSION_UI_IDLE_TIMEOUT_MINS: 'SESSION_UI_IDLE_TIMEOUT_MINS'; +SET: 'SET'; +SETS: 'SETS'; +SETUSER: 'SETUSER'; +SHARE: 'SHARE'; +SHARED: 'SHARED'; +SHARES: 'SHARES'; +SHARE_RESTRICTIONS: 'SHARE_RESTRICTIONS'; +SHOW: 'SHOW'; +SHOWPLAN: 'SHOWPLAN'; +SHOWPLAN_ALL: 'SHOWPLAN_ALL'; +SHOWPLAN_TEXT: 'SHOWPLAN_TEXT'; +SHOWPLAN_XML: 'SHOWPLAN_XML'; +SHOW_INITIAL_ROWS: 'SHOW_INITIAL_ROWS'; +SIGNATURE: 'SIGNATURE'; +SIMPLE: 'SIMPLE'; +SIMULATED_DATA_SHARING_CONSUMER: 'SIMULATED_DATA_SHARING_CONSUMER'; +SINGLE_USER: 'SINGLE_USER'; +SIZE: 'SIZE'; +SIZE_LIMIT: 'SIZE_LIMIT'; +SKIP_: 'SKIP'; +SKIP_BLANK_LINES: 'SKIP_BLANK_LINES'; +SKIP_BYTE_ORDER_MARK: 'SKIP_BYTE_ORDER_MARK'; +SKIP_FILE: 'SKIP_FILE'; +SKIP_FILE_N: 'SKIP_FILE_' DEC_DIGIT+; +SKIP_HEADER: 'SKIP_HEADER'; +SMALL: 'SMALL'; +SNAPPY: 'SNAPPY'; +SNAPPY_COMPRESSION: 'SNAPPY_COMPRESSION'; +SOME: 'SOME'; +SOUNDEX: 'SOUNDEX'; +SOURCE: 'SOURCE'; +SOURCE_COMPRESSION: 'SOURCE_COMPRESSION'; +SPACE_KEYWORD: 'SPACE'; +SPARSE: 'SPARSE'; +SPECIFICATION: 'SPECIFICATION'; +SPLIT: 'SPLIT'; +SPLIT_PART: 'SPLIT_PART'; +SQL: 'SQL'; +SSO_LOGIN_PAGE: 'SSO_LOGIN_PAGE'; +STAGE: 'STAGE'; +STAGES: 'STAGES'; +STAGE_COPY_OPTIONS: 'STAGE_COPY_OPTIONS'; +STAGE_FILE_FORMAT: 'STAGE_FILE_FORMAT'; +STANDARD: 'STANDARD'; +STANDBY: 'STANDBY'; +START: 'START'; +STARTED: 'STARTED'; +STARTS: 'STARTS'; +START_DATE: 'START_DATE'; +START_TIMESTAMP: 'START_TIMESTAMP'; +STATE: 'STATE'; +STATEMENT: 'STATEMENT'; +STATEMENT_QUEUED_TIMEOUT_IN_SECONDS: 'STATEMENT_QUEUED_TIMEOUT_IN_SECONDS'; +STATEMENT_TIMEOUT_IN_SECONDS: 'STATEMENT_TIMEOUT_IN_SECONDS'; +STATIC: 'STATIC'; +STATISTICS: 'STATISTICS'; +STATS: 'STATS'; +STATS_DATE: 'STATS_DATE'; +STATS_STREAM: 'STATS_STREAM'; +STATUS: 'STATUS'; +STATUSONLY: 'STATUSONLY'; +STDEV: 'STDEV'; +STDEVP: 'STDEVP'; +STOP: 'STOP'; +STOPLIST: 'STOPLIST'; +STOPPED: 'STOPPED'; +STORAGE: 'STORAGE'; +STORAGE_ALLOWED_LOCATIONS: 'STORAGE_ALLOWED_LOCATIONS'; +STORAGE_AWS_OBJECT_ACL: 'STORAGE_AWS_OBJECT_ACL'; +STORAGE_AWS_ROLE_ARN: 'STORAGE_AWS_ROLE_ARN'; +STORAGE_BLOCKED_LOCATIONS: 'STORAGE_BLOCKED_LOCATIONS'; +STORAGE_INTEGRATION: 'STORAGE_INTEGRATION'; +STORAGE_PROVIDER: 'STORAGE_PROVIDER'; +STR: 'STR'; +STREAM: 'STREAM'; +STREAMS: 'STREAMS'; +STRICT: 'STRICT'; +STRICT_JSON_OUTPUT: 'STRICT_JSON_OUTPUT'; +STRING_AGG: 'STRING_AGG'; +STRING_ESCAPE: 'STRING_ESCAPE'; +STRIP_NULL_VALUES: 'STRIP_NULL_VALUES'; +STRIP_OUTER_ARRAY: 'STRIP_OUTER_ARRAY'; +STRIP_OUTER_ELEMENT: 'STRIP_OUTER_ELEMENT'; +SUBSTR: 'SUBSTR'; +SUBSTRING: 'SUBSTRING'; +SUM: 'SUM'; +SUPPORTED: 'SUPPORTED'; +SUSPEND: 'SUSPEND'; +SUSPENDED: 'SUSPENDED'; +SUSPEND_IMMEDIATE: 'SUSPEND_IMMEDIATE'; +SUSPEND_TASK_AFTER_NUM_FAILURES: 'SUSPEND_TASK_AFTER_NUM_FAILURES'; +SWAP: 'SWAP'; +SWITCH: 'SWITCH'; +SYNC_PASSWORD: 'SYNC_PASSWORD'; +SYSADMIN: 'SYSADMIN'; +SYSTEM: 'SYSTEM'; +SYSTEM_USER: 'SYSTEM_USER'; +TABLE: 'TABLE'; +TABLEAU_DESKTOP: 'TABLEAU_DESKTOP'; +TABLEAU_SERVER: 'TABLEAU_SERVER'; +TABLES: 'TABLES'; +TABLESAMPLE: 'TABLESAMPLE'; +TABLE_FORMAT: 'TABLE_FORMAT'; +TABULAR: 'TABULAR'; +TAG: 'TAG'; +TAGS: 'TAGS'; +TARGET: 'TARGET'; +TARGET_LAG: 'TARGET_LAG'; +TASK: 'TASK'; +TASKS: 'TASKS'; +TEMP: 'TEMP'; +TEMPORARY: 'TEMPORARY'; +TERSE: 'TERSE'; +TEXTSIZE: 'TEXTSIZE'; +THEN: 'THEN'; +TIES: 'TIES'; +TIME: 'TIME'; +TIMEADD: 'TIMEADD'; +TIMEDIFF: 'TIMEDIFF'; +TIMEOUT: 'TIMEOUT'; +TIMER: 'TIMER'; +TIMESTAMP: 'TIMESTAMP'; +TIMESTAMP_DAY_IS_ALWAYS_24H: 'TIMESTAMP_DAY_IS_ALWAYS_24H'; +TIMESTAMP_FORMAT: 'TIMESTAMP_FORMAT'; +TIMESTAMP_INPUT_FORMAT: 'TIMESTAMP_INPUT_FORMAT'; +TIMESTAMP_LTZ: 'TIMESTAMP_LTZ'; +TIMESTAMP_LTZ_OUTPUT_FORMAT: 'TIMESTAMP_LTZ_OUTPUT_FORMAT'; +TIMESTAMP_NTZ: 'TIMESTAMP_NTZ'; +TIMESTAMP_NTZ_OUTPUT_FORMAT: 'TIMESTAMP_NTZ_OUTPUT_FORMAT'; +TIMESTAMP_OUTPUT_FORMAT: 'TIMESTAMP_OUTPUT_FORMAT'; +TIMESTAMP_TYPE_MAPPING: 'TIMESTAMP_TYPE_MAPPING'; +TIMESTAMP_TZ: 'TIMESTAMP_TZ'; +TIMESTAMP_TZ_OUTPUT_FORMAT: 'TIMESTAMP_TZ_OUTPUT_FORMAT'; +TIMESTAMPADD: 'TIMESTAMPADD'; +TIMESTAMPDIFF: 'TIMESTAMPDIFF'; +TIMEZONE: 'TIMEZONE'; +TIME_FORMAT: 'TIME_FORMAT'; +TIME_INPUT_FORMAT: 'TIME_INPUT_FORMAT'; +TIME_OUTPUT_FORMAT: 'TIME_OUTPUT_FORMAT'; +TO: 'TO'; +TO_BOOLEAN: 'TO_BOOLEAN'; +TO_DATE: 'TO_DATE'; +TOP: 'TOP'; +TORN_PAGE_DETECTION: 'TORN_PAGE_DETECTION'; +TRACKING: 'TRACKING'; +TRACK_CAUSALITY: 'TRACK_CAUSALITY'; +TRAN: 'TRAN'; +TRANSACTION: 'TRANSACTION'; +TRANSACTIONS: 'TRANSACTIONS'; +TRANSACTION_ABORT_ON_ERROR: 'TRANSACTION_ABORT_ON_ERROR'; +TRANSACTION_DEFAULT_ISOLATION_LEVEL: 'TRANSACTION_DEFAULT_ISOLATION_LEVEL'; +TRANSACTION_ID: 'TRANSACTION_ID'; +TRANSFORM_NOISE_WORDS: 'TRANSFORM_NOISE_WORDS'; +TRANSIENT: 'TRANSIENT'; +TRANSLATE: 'TRANSLATE'; +TRIGGER: 'TRIGGER'; +TRIGGERS: 'TRIGGERS'; +TRIM: 'TRIM'; +TRIM_SPACE: 'TRIM_SPACE'; +TRIPLE_DES: 'TRIPLE_DES'; +TRIPLE_DES_3KEY: 'TRIPLE_DES_3KEY'; +TRUE: 'TRUE'; +TRUNCATE: 'TRUNCATE'; +TRUNCATECOLUMNS: 'TRUNCATECOLUMNS'; +TRUSTWORTHY: 'TRUSTWORTHY'; +TRY: 'TRY'; +TRY_CAST: 'TRY_CAST'; +TSEQUAL: 'TSEQUAL'; +TSQL: 'TSQL'; +TWO_DIGIT_CENTURY_START: 'TWO_DIGIT_CENTURY_START'; +TWO_DIGIT_YEAR_CUTOFF: 'TWO_DIGIT_YEAR_CUTOFF'; +TYPE: 'TYPE'; +TYPEPROPERTY: 'TYPEPROPERTY'; +TYPE_ID: 'TYPE_ID'; +TYPE_NAME: 'TYPE_NAME'; +TYPE_WARNING: 'TYPE_WARNING'; +UN: 'UN'; +UNBOUNDED: 'UNBOUNDED'; +UNCHECKED: 'UNCHECKED'; +UNCOMMITTED: 'UNCOMMITTED'; +UNDROP: 'UNDROP'; +UNICODE: 'UNICODE'; +UNION: 'UNION'; +UNIQUE: 'UNIQUE'; +UNKNOWN: 'UNKNOWN'; +UNLIMITED: 'UNLIMITED'; +UNLOCK: 'UNLOCK'; +UNMASK: 'UNMASK'; +UNMATCHED: 'UNMATCHED'; +UNPIVOT: 'UNPIVOT'; +UNSAFE: 'UNSAFE'; +UNSET: 'UNSET'; +UNSUPPORTED_DDL_ACTION: 'UNSUPPORTED_DDL_ACTION'; +UOW: 'UOW'; +UPDATE: 'UPDATE'; +UPDLOCK: 'UPDLOCK'; +UPPER: 'UPPER'; +URL: 'URL'; +USAGE: 'USAGE'; +USE: 'USE'; +USED: 'USED'; +USER: 'USER'; +USERADMIN: 'USERADMIN'; +USERS: 'USERS'; +USER_SPECIFIED: 'USER_SPECIFIED'; +USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE: 'USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE'; +USER_TASK_TIMEOUT_MS: 'USER_TASK_TIMEOUT_MS'; +USE_ANY_ROLE: 'USE_ANY_ROLE'; +USE_CACHED_RESULT: 'USE_CACHED_RESULT'; +USING: 'USING'; +UTF8: 'UTF8'; +VALIDATE: 'VALIDATE'; +VALIDATION: 'VALIDATION'; +VALIDATION_MODE: 'VALIDATION_MODE'; +VALID_XML: 'VALID_XML'; +VALUE: 'VALUE'; +VALUES: 'VALUES'; +VAR: 'VAR'; +VARIABLES: 'VARIABLES'; +VARP: 'VARP'; +VARYING: 'VARYING'; +VERSION: 'VERSION'; +VIEW: 'VIEW'; +VIEWS: 'VIEWS'; +VIEW_METADATA: 'VIEW_METADATA'; +VISIBILITY: 'VISIBILITY'; +VOLATILE: 'VOLATILE'; +WAIT: 'WAIT'; +WAREHOUSE: 'WAREHOUSE'; +WAREHOUSES: 'WAREHOUSES'; +WAREHOUSE_SIZE: 'WAREHOUSE_SIZE'; +WEEKLY: 'WEEKLY'; +WEEK_OF_YEAR_POLICY: 'WEEK_OF_YEAR_POLICY'; +WEEK_START: 'WEEK_START'; +WELL_FORMED_XML: 'WELL_FORMED_XML'; +WHEN: 'WHEN'; +WHERE: 'WHERE'; +WITH: 'WITH'; +WITHIN: 'WITHIN'; +WITHOUT: 'WITHOUT'; +WITHOUT_ARRAY_WRAPPER: 'WITHOUT_ARRAY_WRAPPER'; +WORK: 'WORK'; +WORKLOAD: 'WORKLOAD'; +WRITE: 'WRITE'; +X4LARGE: 'X4LARGE'; +X5LARGE: 'X5LARGE'; +X6LARGE: 'X6LARGE'; +XLARGE: 'XLARGE'; +XLOCK: 'XLOCK'; +XML: 'XML'; +XML_Q: '\'XML\''; +XSMALL: 'XSMALL'; +XXLARGE: 'XXLARGE'; +XXXLARGE: 'XXXLARGE'; +YEARLY: 'YEARLY'; +ZSTD: 'ZSTD'; + + +ARRAY: 'ARRAY'; +ARRAY_Q: '\'ARRAY\''; +BIGINT: 'BIGINT'; +BINARY: 'BINARY'; +BOOLEAN: 'BOOLEAN'; +BYTEINT: 'BYTEINT'; +CHAR_VARYING: 'CHAR VARYING'; +DATE: 'DATE'; +DATETIME: 'DATETIME'; +DECIMAL_: 'DECIMAL'; +FLOAT4: 'FLOAT4'; +FLOAT8: 'FLOAT8'; +FLOAT_: 'FLOAT'; +GEOGRAPHY: 'GEOGRAPHY'; +GEOMETRY: 'GEOMETRY'; +INTEGER: 'INTEGER'; +NCHAR_VARYING: 'NCHAR VARYING'; +NUMERIC: 'NUMERIC'; +NVARCHAR2: 'NVARCHAR2'; +NVARCHAR: 'NVARCHAR'; +REAL_: 'REAL'; +SMALLINT: 'SMALLINT'; +STRING_: 'STRING'; +TEXT: 'TEXT'; +TINYINT: 'TINYINT'; +VARBINARY: 'VARBINARY'; +VARCHAR: 'VARCHAR'; +VARIANT: 'VARIANT'; + +LISTAGG: 'LISTAGG'; + +DUMMY: 'DUMMY'; //Dummy is not a keyword but rules reference it. As to be cleaned. + +// Build id contains the non reserved keywords stop. + +SPACE: [ \t\r\n]+ -> channel(HIDDEN); + +SQL_COMMENT: '/*' (SQL_COMMENT | .)*? '*/' -> channel(HIDDEN); +LINE_COMMENT: '--' ~[\r\n]* -> channel(HIDDEN); +LINE_COMMENT_2: '//' ~[\r\n]* -> channel(HIDDEN); + +// TODO: ID can be not only Latin. +DOUBLE_QUOTE_ID: '"' ~'"'+ '"'; +DOUBLE_QUOTE_BLANK: '""'; +SINGLE_QUOTE: '\''; + +ID: [A-Z_] ( [A-Z0-9_@$] )*; +ID2: '$' [A-Z_] ( [A-Z0-9_] )*; + + +S3_PATH: '\'s3://\''; +GCS_PATH: '\'gcs://\''; +AZURE_PATH: '\'azure://\''; +FILE_PATH: 'file://'; //file:/// + +DBL_DOLLAR: '$$' (~'$' | '\\$')*? '$$'; + +STRING: '\'' (~'\'' | '\'\'')* '\''; + +DECIMAL: DEC_DIGIT+; +FLOAT: DEC_DOT_DEC; +REAL: (DECIMAL | DEC_DOT_DEC) ('E' [+-]? DEC_DIGIT+); + +CHAR_LITERAL: '\'' (~['\\\r\n] | EscapeSequence) '\''; + +fragment EscapeSequence + : '\\' [btnfr"'\\] + | '\\' ([0-3]? [0-7])? [0-7] + | '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit + ; + +fragment HexDigit + : [0-9a-f] + ; + +ARROW: '->'; +ASSOC: '=>'; + +NE: '!='; +LTGT: '<>'; +EQ: '='; +GT: '>'; +GE: '>='; +LT: '<'; +LE: '<='; +EXCLAMATION: '!'; + + +PIPE_PIPE: '||'; +DOT: '.'; +UNDERLINE: '_'; +AT: '@'; +AT_Q: '\'@\''; +//HASH: '#'; +DOLLAR: '$'; +LR_BRACKET: '('; +RR_BRACKET: ')'; +LSB: '['; +RSB: ']'; +LCB: '{'; +RCB: '}'; +COMMA: ','; +SEMI: ';'; +COLON: ':'; +COLON_COLON: '::'; +STAR: '*'; +DIVIDE: '/'; +MODULE: '%'; +PLUS: '+'; +MINUS: '-'; + +PLACEHOLDER: '?'; + +fragment LETTER: [A-Z_]; +fragment DEC_DOT_DEC: (DEC_DIGIT+ '.' DEC_DIGIT+ | DEC_DIGIT+ '.' | '.' DEC_DIGIT+); +fragment DEC_DIGIT: [0-9]; + + +fragment FullWidthLetter options { caseInsensitive=false; } + : '\u00c0'..'\u00d6' + | '\u00d8'..'\u00f6' + | '\u00f8'..'\u00ff' + | '\u0100'..'\u1fff' + | '\u2c00'..'\u2fff' + | '\u3040'..'\u318f' + | '\u3300'..'\u337f' + | '\u3400'..'\u3fff' + | '\u4e00'..'\u9fff' + | '\ua000'..'\ud7ff' + | '\uf900'..'\ufaff' + | '\uff00'..'\ufff0' + // | '\u10000'..'\u1F9FF' //not support four bytes chars + // | '\u20000'..'\u2FA1F' + ; diff --git a/snowflake/SnowflakeParser.g4 b/snowflake/SnowflakeParser.g4 new file mode 100644 index 0000000..b154977 --- /dev/null +++ b/snowflake/SnowflakeParser.g4 @@ -0,0 +1,5054 @@ +/* +Snowflake Database grammar. +The MIT License (MIT). + +Copyright (c) 2022, Michał Lorek. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +parser grammar SnowflakeParser; + +options { tokenVocab=SnowflakeLexer; } + +snowflake_file + : (batch (SEMI batch)* SEMI?)? EOF + ; + +batch + : sql_command + ; + +sql_command + : ddl_command + | dml_command + | show_command + | use_command + | describe_command + | other_command + ; + +ddl_command + : alter_command + | create_command + | drop_command + | undrop_command + ; + +dml_command + : query_statement + | insert_statement + | insert_multi_table_statement + | update_statement + | delete_statement + | merge_statement + ; + +insert_statement + : INSERT OVERWRITE? INTO object_name ( '(' column_list ')' )? + (values_builder | select_statement) + ; + +insert_multi_table_statement + : INSERT OVERWRITE? ALL into_clause2 + | INSERT OVERWRITE? (FIRST | ALL) + (WHEN predicate THEN into_clause2+)+ + (ELSE into_clause2)? + subquery + ; + +into_clause2 + : INTO object_name ( '(' column_list ')')? values_list? + ; + +values_list + : VALUES '(' value_item (COMMA value_item)* ')' + ; + +value_item + : column_name + | DEFAULT + | NULL_ + ; + +merge_statement + : MERGE INTO object_name USING table_source ON search_condition merge_matches + ; + +merge_matches + : WHEN MATCHED (AND search_condition )? THEN merge_update_delete + | WHEN NOT MATCHED (AND search_condition )? THEN merge_insert + ; + +merge_update_delete + // : UPDATE SET column_name EQ expr ( column_name EQ expr )* + : UPDATE SET (alias DOT)? column_name EQ expr ( column_name EQ expr )* + | DELETE + ; + +merge_insert + : INSERT ( '(' column_list ')' )? VALUES '(' expr_list ')' + ; + +update_statement + : UPDATE object_name + SET column_name EQ expr (COMMA column_name EQ expr)* + (FROM table_sources)? + (WHERE search_condition)? + ; + +table_or_query + : object_name + | '(' subquery ')' + ; + +delete_statement + : DELETE FROM object_name + (USING table_or_query (COMMA table_or_query)? )? + (WHERE search_condition)? + ; + +values_builder + : VALUES '(' expr_list ')' (COMMA '(' expr_list ')' )? + ; + +other_command + : copy_into_table + | copy_into_location + | comment + | commit + | execute_immediate + | execute_task + | explain + | get_dml + | grant_ownership + | grant_to_role + | grant_to_share + | grant_role + | list + | put + | remove + | revoke_from_role + | revoke_from_share + | revoke_role + | rollback + | set + | truncate_materialized_view + | truncate_table + | unset + | call + ; + +copy_into_table + : COPY INTO object_name + FROM ( internal_stage | external_stage | external_location ) + files? + pattern? + file_format? + copy_options* + ( VALIDATION_MODE EQ (RETURN_N_ROWS | RETURN_ERRORS | RETURN_ALL_ERRORS) )? +// + /* Data load with transformation */ + | COPY INTO object_name ( '(' column_list ')' )? +// FROM '(' SELECT expr_list +// FROM ( internal_stage | external_stage ) ')' + files? + pattern? + file_format? + copy_options* + ; + +external_location + //(for Amazon S3) + : S3_PATH //'s3://[/]' +// ( ( STORAGE_INTEGRATION EQ id_ )? +// | ( CREDENTIALS EQ '(' ( AWS_KEY_ID EQ string AWS_SECRET_KEY EQ string ( AWS_TOKEN EQ string )? ) ')' )? +// )? +// [ ENCRYPTION = ( [ TYPE = 'AWS_CSE' ] [ MASTER_KEY = '' ] | +// [ TYPE = 'AWS_SSE_S3' ] | +// [ TYPE = 'AWS_SSE_KMS' [ KMS_KEY_ID = '' ] ] | +// [ TYPE = 'NONE' ] ) ] + // (for Google Cloud Storage) + | GCS_PATH //'gcs://[/]' +// ( STORAGE_INTEGRATION EQ id_ )? + //[ ENCRYPTION = ( [ TYPE = 'GCS_SSE_KMS' ] [ KMS_KEY_ID = '' ] | [ TYPE = 'NONE' ] ) ] + // (for Microsoft Azure) + | AZURE_PATH //'azure://.blob.core.windows.net/[/]' +// ( ( STORAGE_INTEGRATION EQ id_ )? +// | ( CREDENTIALS EQ '(' ( AZURE_SAS_TOKEN EQ string ) ')' ) +// )? + //[ ENCRYPTION = ( [ TYPE = { 'AZURE_CSE' | 'NONE' } ] [ MASTER_KEY = '' ] ) ] + ; + +files + : FILES EQ '(' string (COMMA string)* ')' + ; + +file_format + : FILE_FORMAT EQ '(' (format_name | format_type) ')' + ; + +format_name + : FORMAT_NAME EQ string + ; + +format_type + : TYPE EQ ( CSV | JSON | AVRO | ORC | PARQUET | XML ) format_type_options* + ; + +stage_file_format + : STAGE_FILE_FORMAT EQ '(' ( FORMAT_NAME EQ string ) + | (TYPE EQ ( CSV | JSON | AVRO | ORC | PARQUET | XML ) format_type_options+ ) + ')' + ; + +copy_into_location + : COPY INTO ( internal_stage | external_stage | external_location ) + FROM ( object_name | '(' query_statement ')' ) + partition_by? + file_format? + copy_options? + ( VALIDATION_MODE EQ RETURN_ROWS )? + HEADER? + ; + +comment + : COMMENT if_exists? ON object_type_name object_name IS string + | COMMENT if_exists? ON COLUMN full_column_name IS string + ; + +commit + : COMMIT WORK? + ; + +execute_immediate + : EXECUTE IMMEDIATE string ( USING '(' id_ (COMMA id_)* ')' )? + | EXECUTE IMMEDIATE id_ ( USING '(' id_ (COMMA id_)* ')' )? + | EXECUTE IMMEDIATE ID2 ( USING '(' id_ (COMMA id_)* ')' )? + ; + +execute_task + : EXECUTE TASK object_name + ; + +explain + : EXPLAIN ( USING (TABULAR | JSON | TEXT) )? sql_command + ; + +parallel + : PARALLEL EQ num + ; + +get_dml + : GET internal_stage FILE_PATH + parallel? + pattern? + ; + +grant_ownership + : GRANT OWNERSHIP + ( ON ( object_type_name object_name | ALL object_type_plural IN ( DATABASE id_ | SCHEMA schema_name ) ) + | ON FUTURE object_type_plural IN ( DATABASE id_ | SCHEMA schema_name ) + ) + TO ROLE id_ ( ( REVOKE | COPY ) CURRENT GRANTS )? + ; + +grant_to_role + : GRANT ( + ( global_privileges | ALL PRIVILEGES? ) ON ACCOUNT + | ( account_object_privileges | ALL PRIVILEGES? ) ON ( USER | RESOURCE MONITOR | WAREHOUSE | DATABASE | INTEGRATION ) object_name + | ( schema_privileges | ALL PRIVILEGES? ) ON ( SCHEMA schema_name | ALL SCHEMAS IN DATABASE id_ ) + | ( schema_privileges | ALL PRIVILEGES? ) ON ( FUTURE SCHEMAS IN DATABASE id_ ) + | ( schema_object_privileges | ALL PRIVILEGES? ) ON ( object_type object_name | ALL object_type_plural IN ( DATABASE id_ | SCHEMA schema_name ) ) + | ( schema_object_privileges | ALL PRIVILEGES? ) ON FUTURE object_type_plural IN ( DATABASE id_ | SCHEMA schema_name ) + ) + TO ROLE? id_ (WITH GRANT OPTION)? + ; + +global_privileges + : global_privilege (COMMA global_privilege)* + ; + +global_privilege + : CREATE ( ACCOUNT + | DATA EXCHANGE LISTING + | DATABASE + | INTEGRATION + | NETWORK POLICY + | ROLE + | SHARE + | USER + | WAREHOUSE ) + | ( APPLY MASKING POLICY + | APPLY ROW ACCESS POLICY + | APPLY SESSION POLICY + | APPLY TAG + | ATTACH POLICY ) + | ( EXECUTE TASK + | IMPORT SHARE + | MANAGE GRANTS + | MONITOR ( EXECUTION | USAGE ) + | OVERRIDE SHARE RESTRICTIONS ) + ; + +account_object_privileges + : account_object_privilege (COMMA account_object_privilege)* + ; + +account_object_privilege + : MONITOR + | MODIFY + | USAGE + | OPERATE + | CREATE SCHEMA + | IMPORTED PRIVILEGES + | USE_ANY_ROLE + ; + +schema_privileges + : schema_privilege (COMMA schema_privilege)* + ; + +schema_privilege + : MODIFY + | MONITOR + | USAGE + | CREATE ( TABLE + | EXTERNAL TABLE + | VIEW + | MATERIALIZED VIEW + | MASKING POLICY + | ROW ACCESS POLICY + | SESSION POLICY + | TAG + | SEQUENCE + | FUNCTION + | PROCEDURE + | FILE FORMAT + | STAGE + | PIPE + | STREAM + | TASK ) + | ADD SEARCH OPTIMIZATION + ; + +schema_object_privileges + : schema_object_privilege (COMMA schema_object_privilege)* + ; + +schema_object_privilege + : SELECT + | INSERT + | UPDATE + | DELETE + | TRUNCATE + | REFERENCES + | USAGE + | READ (COMMA WRITE)? + | MONITOR + | OPERATE + | APPLY + ; + +grant_to_share + : GRANT object_privilege ON + ( DATABASE id_ + | SCHEMA id_ + | FUNCTION id_ + | ( TABLE object_name | ALL TABLES IN SCHEMA schema_name ) + | VIEW id_ ) + TO SHARE id_ + ; + +object_privilege + : USAGE + | SELECT + | REFERENCE_USAGE + ; + +grant_role + : GRANT ROLE role_name TO (ROLE role_name | USER id_) + ; + +role_name + : system_defined_role + | id_ + ; + +system_defined_role + : ORGADMIN + | ACCOUNTADMIN + | SECURITYADMIN + | USERADMIN + | SYSADMIN + | PUBLIC + ; + +list + : LIST ( internal_stage | external_stage ) + pattern? + ; + +// @[.][/] +// | @[.]%[/] +// | @~[/] +internal_stage + : AT id_ '/' + ; + +// @[.][/] +external_stage + : AT id_ '/' + ; + +put + : PUT FILE_PATH internal_stage + ( PARALLEL EQ num )? + ( AUTO_COMPRESS EQ true_false )? + ( SOURCE_COMPRESSION EQ (AUTO_DETECT | GZIP | BZ2 | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE) )? + ( OVERWRITE EQ true_false )? + ; + +remove + : REMOVE ( internal_stage | external_stage ) + pattern? + ; + +revoke_from_role + : REVOKE (GRANT OPTION FOR)? + ( + ( global_privilege | ALL PRIVILEGES? ) ON ACCOUNT + | ( account_object_privileges | ALL PRIVILEGES? ) ON ( RESOURCE MONITOR | WAREHOUSE | DATABASE | INTEGRATION ) object_name + | ( schema_privileges | ALL PRIVILEGES? ) ON ( SCHEMA schema_name | ALL SCHEMAS IN DATABASE id_ ) + | ( schema_privileges | ALL PRIVILEGES? ) ON ( FUTURE SCHEMAS IN DATABASE ) + | ( schema_object_privileges | ALL PRIVILEGES? ) ON ( object_type object_name | ALL object_type_plural IN SCHEMA schema_name ) + | ( schema_object_privileges | ALL PRIVILEGES? ) ON FUTURE object_type_plural IN ( DATABASE id_ | SCHEMA schema_name ) + ) + FROM ROLE? id_ cascade_restrict? + ; + +revoke_from_share + : REVOKE object_privilege ON + ( DATABASE id_ + | SCHEMA schema_name + | ( TABLE object_name | ALL TABLES IN SCHEMA schema_name ) + | ( VIEW object_name | ALL VIEWS IN SCHEMA schema_name ) ) + FROM SHARE id_ + ; + +revoke_role + : REVOKE ROLE role_name FROM (ROLE role_name | USER id_) + ; + +rollback + : ROLLBACK WORK? + ; + +set + : SET id_ EQ expr + | SET LR_BRACKET id_ ( COMMA id_ )* RR_BRACKET EQ LR_BRACKET expr ( COMMA expr )* RR_BRACKET + ; + +truncate_materialized_view + : TRUNCATE MATERIALIZED VIEW object_name + ; + +truncate_table + : TRUNCATE TABLE? if_exists? object_name + ; + +unset + : UNSET id_ + | UNSET '(' id_ (COMMA id_)* ')' + ; + +// alter commands +alter_command + : alter_account + | alter_alert + | alter_api_integration + | alter_connection + | alter_database + | alter_dynamic_table + | alter_external_table + | alter_failover_group + | alter_file_format + | alter_function + | alter_masking_policy + | alter_materialized_view + | alter_network_policy + | alter_notification_integration + | alter_pipe + | alter_procedure + | alter_replication_group + | alter_resource_monitor + | alter_role + | alter_row_access_policy + | alter_schema + | alter_security_integration + | alter_security_integration_external_oauth + | alter_security_integration_snowflake_oauth + | alter_security_integration_saml2 + | alter_security_integration_scim + | alter_sequence + | alter_session + | alter_session_policy + | alter_share + | alter_stage + | alter_storage_integration + | alter_stream + | alter_table + | alter_table_alter_column + | alter_tag + | alter_task + | alter_user + | alter_view + | alter_warehouse + ; + +account_params + : ALLOW_ID_TOKEN EQ true_false + | CLIENT_ENCRYPTION_KEY_SIZE EQ num + | ENFORCE_SESSION_POLICY EQ true_false + | EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST EQ true_false + | INITIAL_REPLICATION_SIZE_LIMIT_IN_TB EQ num + | NETWORK_POLICY EQ string + | PERIODIC_DATA_REKEYING EQ true_false + | PREVENT_UNLOAD_TO_INLINE_URL EQ true_false + | PREVENT_UNLOAD_TO_INTERNAL_STAGES EQ true_false + | REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION EQ true_false + | REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION EQ true_false + | SAML_IDENTITY_PROVIDER EQ json_literal + | SESSION_POLICY EQ string + | SSO_LOGIN_PAGE EQ true_false + ; + +object_params + : DATA_RETENTION_TIME_IN_DAYS EQ num + | MAX_DATA_EXTENSION_TIME_IN_DAYS EQ num + | default_ddl_collation + | MAX_CONCURRENCY_LEVEL EQ num + | NETWORK_POLICY EQ string + | PIPE_EXECUTION_PAUSED EQ true_false + | SESSION_POLICY EQ string + | STATEMENT_QUEUED_TIMEOUT_IN_SECONDS EQ num + | STATEMENT_TIMEOUT_IN_SECONDS EQ num + ; + +default_ddl_collation + : DEFAULT_DDL_COLLATION_ EQ string + ; + +object_properties + : PASSWORD EQ string + | LOGIN_NAME EQ string + | DISPLAY_NAME EQ string + | FIRST_NAME EQ string + | MIDDLE_NAME EQ string + | LAST_NAME EQ string + | EMAIL EQ string + | MUST_CHANGE_PASSWORD EQ true_false + | DISABLED EQ true_false + | DAYS_TO_EXPIRY EQ num + | MINS_TO_UNLOCK EQ num + | DEFAULT_WAREHOUSE EQ string + | DEFAULT_NAMESPACE EQ string + | DEFAULT_ROLE EQ string + //| DEFAULT_SECONDARY_ROLES EQ '(' 'ALL' ')' + | MINS_TO_BYPASS_MFA EQ num + | RSA_PUBLIC_KEY EQ string + | RSA_PUBLIC_KEY_2 EQ string + | comment_clause + ; + +session_params + : ABORT_DETACHED_QUERY EQ true_false + | AUTOCOMMIT EQ true_false + | BINARY_INPUT_FORMAT EQ string + | BINARY_OUTPUT_FORMAT EQ string + | DATE_INPUT_FORMAT EQ string + | DATE_OUTPUT_FORMAT EQ string + | ERROR_ON_NONDETERMINISTIC_MERGE EQ true_false + | ERROR_ON_NONDETERMINISTIC_UPDATE EQ true_false + | JSON_INDENT EQ num + | LOCK_TIMEOUT EQ num + | QUERY_TAG EQ string + | ROWS_PER_RESULTSET EQ num + | SIMULATED_DATA_SHARING_CONSUMER EQ string + | STATEMENT_TIMEOUT_IN_SECONDS EQ num + | STRICT_JSON_OUTPUT EQ true_false + | TIMESTAMP_DAY_IS_ALWAYS_24H EQ true_false + | TIMESTAMP_INPUT_FORMAT EQ string + | TIMESTAMP_LTZ_OUTPUT_FORMAT EQ string + | TIMESTAMP_NTZ_OUTPUT_FORMAT EQ string + | TIMESTAMP_OUTPUT_FORMAT EQ string + | TIMESTAMP_TYPE_MAPPING EQ string + | TIMESTAMP_TZ_OUTPUT_FORMAT EQ string + | TIMEZONE EQ string + | TIME_INPUT_FORMAT EQ string + | TIME_OUTPUT_FORMAT EQ string + | TRANSACTION_DEFAULT_ISOLATION_LEVEL EQ string + | TWO_DIGIT_CENTURY_START EQ num + | UNSUPPORTED_DDL_ACTION EQ string + | USE_CACHED_RESULT EQ true_false + | WEEK_OF_YEAR_POLICY EQ num + | WEEK_START EQ num + ; + +alter_account + : ALTER ACCOUNT alter_account_opts + ; + +enabled_true_false + : ENABLED EQ true_false + ; + +alter_alert + : ALTER ALERT if_exists? id_ ( resume_suspend + | SET alert_set_clause+ + | UNSET alert_unset_clause+ + | MODIFY CONDITION EXISTS '(' alert_condition ')' + | MODIFY ACTION alert_action + ) + ; + +resume_suspend + : RESUME + | SUSPEND + ; + +alert_set_clause + : WAREHOUSE EQ id_ + | SCHEDULE EQ string + | comment_clause + ; + +alert_unset_clause + : WAREHOUSE + | SCHEDULE + | COMMENT + ; + +alter_api_integration + : ALTER API? INTEGRATION if_exists? id_ SET + ( API_AWS_ROLE_ARN EQ string )? + ( AZURE_AD_APPLICATION_ID EQ string )? + ( API_KEY EQ string )? + enabled_true_false? + ( API_ALLOWED_PREFIXES EQ '(' string ')' )? + ( API_BLOCKED_PREFIXES EQ '(' string ')' )? + comment_clause? + + | ALTER API? INTEGRATION id_ set_tags + | ALTER API? INTEGRATION id_ unset_tags + | ALTER API? INTEGRATION if_exists? id_ UNSET api_integration_property (COMMA api_integration_property)* + ; + +api_integration_property + : API_KEY + | ENABLED + | API_BLOCKED_PREFIXES + | COMMENT + ; + +alter_connection + : ALTER CONNECTION alter_connection_opts + ; + +alter_database + : ALTER DATABASE if_exists? id_ RENAME TO id_ + | ALTER DATABASE if_exists? id_ SWAP WITH id_ + | ALTER DATABASE if_exists? id_ SET ( DATA_RETENTION_TIME_IN_DAYS EQ num )? + ( MAX_DATA_EXTENSION_TIME_IN_DAYS EQ num )? + default_ddl_collation? + comment_clause? + | ALTER DATABASE id_ set_tags + | ALTER DATABASE id_ unset_tags + | ALTER DATABASE if_exists? id_ UNSET database_property (COMMA database_property)* + | ALTER DATABASE id_ ENABLE REPLICATION TO ACCOUNTS account_id_list (IGNORE EDITION CHECK)? + | ALTER DATABASE id_ DISABLE REPLICATION ( TO ACCOUNTS account_id_list )? + | ALTER DATABASE id_ REFRESH + // Database Failover + | ALTER DATABASE id_ ENABLE FAILOVER TO ACCOUNTS account_id_list + | ALTER DATABASE id_ DISABLE FAILOVER ( TO ACCOUNTS account_id_list )? + | ALTER DATABASE id_ PRIMARY + ; + +database_property + : DATA_RETENTION_TIME_IN_DAYS + | MAX_DATA_EXTENSION_TIME_IN_DAYS + | DEFAULT_DDL_COLLATION_ + | COMMENT + ; + +account_id_list + : account_identifier (COMMA account_identifier)* + ; + +alter_dynamic_table + : ALTER DYNAMIC TABLE id_ ( resume_suspend + | REFRESH + | SET WAREHOUSE EQ id_ + ) + ; + +alter_external_table + : ALTER EXTERNAL TABLE if_exists? object_name REFRESH string? + | ALTER EXTERNAL TABLE if_exists? object_name ADD FILES '(' string_list ')' + | ALTER EXTERNAL TABLE if_exists? object_name REMOVE FILES '(' string_list ')' + | ALTER EXTERNAL TABLE if_exists? object_name SET + ( AUTO_REFRESH EQ true_false )? + tag_decl_list? + | ALTER EXTERNAL TABLE if_exists? object_name unset_tags + //Partitions added and removed manually + | ALTER EXTERNAL TABLE object_name if_exists? ADD PARTITION '(' column_name EQ string (COMMA column_name EQ string)* ')' LOCATION string + | ALTER EXTERNAL TABLE object_name if_exists? DROP PARTITION LOCATION string + ; + +ignore_edition_check + : IGNORE EDITION CHECK + ; + +replication_schedule + : REPLICATION_SCHEDULE EQ string + ; + +db_name_list + : id_ (COMMA id_)* + ; + +share_name_list + : id_ (COMMA id_)* + ; + +full_acct_list + : full_acct (COMMA full_acct)* + ; + +alter_failover_group + //Source Account + : ALTER FAILOVER GROUP if_exists? id_ RENAME TO id_ + | ALTER FAILOVER GROUP if_exists? id_ SET ( OBJECT_TYPES EQ object_type_list )? replication_schedule? + | ALTER FAILOVER GROUP if_exists? id_ SET + OBJECT_TYPES EQ object_type_list +// ALLOWED_INTEGRATION_TYPES EQ [ , ... ] ] + replication_schedule? + | ALTER FAILOVER GROUP if_exists? id_ ADD db_name_list TO ALLOWED_DATABASES + | ALTER FAILOVER GROUP if_exists? id_ MOVE DATABASES db_name_list TO FAILOVER GROUP id_ + | ALTER FAILOVER GROUP if_exists? id_ REMOVE db_name_list FROM ALLOWED_DATABASES + | ALTER FAILOVER GROUP if_exists? id_ ADD share_name_list TO ALLOWED_SHARES + | ALTER FAILOVER GROUP if_exists? id_ MOVE SHARES share_name_list TO FAILOVER GROUP id_ + | ALTER FAILOVER GROUP if_exists? id_ REMOVE share_name_list FROM ALLOWED_SHARES + | ALTER FAILOVER GROUP if_exists? id_ ADD full_acct_list TO ALLOWED_ACCOUNTS ignore_edition_check? + | ALTER FAILOVER GROUP if_exists? id_ REMOVE full_acct_list FROM ALLOWED_ACCOUNTS + //Target Account + | ALTER FAILOVER GROUP if_exists? id_ ( REFRESH | PRIMARY | SUSPEND | RESUME ) + ; + +alter_file_format + : ALTER FILE FORMAT if_exists? id_ RENAME TO id_ + | ALTER FILE FORMAT if_exists? id_ SET ( format_type_options* comment_clause? ) + ; + +alter_function + : alter_function_signature RENAME TO id_ + | alter_function_signature SET comment_clause + | alter_function_signature SET SECURE + | alter_function_signature UNSET ( SECURE | COMMENT ) + // External Functions + | alter_function_signature SET API_INTEGRATION EQ id_ + | alter_function_signature SET HEADERS EQ '(' header_decl* ')' + | alter_function_signature SET CONTEXT_HEADERS EQ '(' id_* ')' + | alter_function_signature SET MAX_BATCH_ROWS EQ num + | alter_function_signature SET COMPRESSION EQ compression_type + | alter_function_signature SET ( REQUEST_TRANSLATOR | RESPONSE_TRANSLATOR ) EQ id_ + | alter_function_signature UNSET ( COMMENT | HEADERS | CONTEXT_HEADERS | MAX_BATCH_ROWS | COMPRESSION | SECURE | REQUEST_TRANSLATOR | RESPONSE_TRANSLATOR ) + ; + +alter_function_signature + : ALTER FUNCTION if_exists? id_ '(' data_type_list? ')' + ; + +data_type_list + : data_type (COMMA data_type)* + ; + +alter_masking_policy + : ALTER MASKING POLICY if_exists? id_ SET BODY ARROW expr + | ALTER MASKING POLICY if_exists? id_ RENAME TO id_ + | ALTER MASKING POLICY if_exists? id_ SET comment_clause + ; + +alter_materialized_view + : ALTER MATERIALIZED VIEW id_ ( + RENAME TO id_ + | CLUSTER BY '(' expr_list ')' + | DROP CLUSTERING KEY + | resume_suspend RECLUSTER? + | SET ( + SECURE? + comment_clause? ) + | UNSET ( + SECURE + | COMMENT ) + ) + ; + +alter_network_policy + : ALTER NETWORK POLICY alter_network_policy_opts + ; + +alter_notification_integration + : ALTER NOTIFICATION? INTEGRATION if_exists? id_ SET + enabled_true_false? + cloud_provider_params_auto + comment_clause? + // Push notifications + | ALTER NOTIFICATION? INTEGRATION if_exists? id_ SET + enabled_true_false? + cloud_provider_params_push + comment_clause? + | ALTER NOTIFICATION? INTEGRATION id_ set_tags + | ALTER NOTIFICATION? INTEGRATION id_ unset_tags + | ALTER NOTIFICATION? INTEGRATION if_exists id_ UNSET (ENABLED | COMMENT) + ; + +alter_pipe + : ALTER PIPE if_exists? id_ SET ( object_properties? comment_clause? ) + | ALTER PIPE id_ set_tags + | ALTER PIPE id_ unset_tags + | ALTER PIPE if_exists? id_ UNSET PIPE_EXECUTION_PAUSED EQ true_false + | ALTER PIPE if_exists? id_ UNSET COMMENT + | ALTER PIPE if_exists? id_ REFRESH ( PREFIX EQ string )? ( MODIFIED_AFTER EQ string )? + ; + +alter_procedure + : ALTER PROCEDURE if_exists? id_ '(' data_type_list? ')' RENAME TO id_ + | ALTER PROCEDURE if_exists? id_ '(' data_type_list? ')' SET comment_clause + | ALTER PROCEDURE if_exists? id_ '(' data_type_list? ')' UNSET COMMENT + | ALTER PROCEDURE if_exists? id_ '(' data_type_list? ')' EXECUTE AS caller_owner + ; + +alter_replication_group + //Source Account + : ALTER REPLICATION GROUP if_exists? id_ RENAME TO id_ + | ALTER REPLICATION GROUP if_exists? id_ SET + ( OBJECT_TYPES EQ object_type_list )? + ( REPLICATION_SCHEDULE EQ string )? + | ALTER REPLICATION GROUP if_exists? id_ SET + OBJECT_TYPES EQ object_type_list + ALLOWED_INTEGRATION_TYPES EQ integration_type_name (COMMA integration_type_name)* + ( REPLICATION_SCHEDULE EQ string )? + | ALTER REPLICATION GROUP if_exists? id_ ADD db_name_list TO ALLOWED_DATABASES + | ALTER REPLICATION GROUP if_exists? id_ MOVE DATABASES db_name_list TO REPLICATION GROUP id_ + | ALTER REPLICATION GROUP if_exists? id_ REMOVE db_name_list FROM ALLOWED_DATABASES + | ALTER REPLICATION GROUP if_exists? id_ ADD share_name_list TO ALLOWED_SHARES + | ALTER REPLICATION GROUP if_exists? id_ MOVE SHARES share_name_list TO REPLICATION GROUP id_ + | ALTER REPLICATION GROUP if_exists? id_ REMOVE share_name_list FROM ALLOWED_SHARES + | ALTER REPLICATION GROUP if_exists? id_ ADD account_id_list TO ALLOWED_ACCOUNTS + ignore_edition_check? + | ALTER REPLICATION GROUP if_exists? id_ REMOVE account_id_list FROM ALLOWED_ACCOUNTS + //Target Account + | ALTER REPLICATION GROUP if_exists? id_ REFRESH + | ALTER REPLICATION GROUP if_exists? id_ SUSPEND + | ALTER REPLICATION GROUP if_exists? id_ RESUME + ; + +credit_quota + : CREDIT_QUOTA EQ num + ; + +frequency + : FREQUENCY EQ ( MONTHLY | DAILY | WEEKLY | YEARLY | NEVER ) + ; + +notify_users + : NOTIFY_USERS EQ LR_BRACKET id_ (COMMA id_)* RR_BRACKET + ; + +triggerDefinition + : ON num PERCENT DO ( SUSPEND | SUSPEND_IMMEDIATE | NOTIFY ) + ; + +alter_resource_monitor + : ALTER RESOURCE MONITOR if_exists? id_ + ( + SET + credit_quota? + frequency? + ( START_TIMESTAMP EQ LR_BRACKET string | IMMEDIATELY RR_BRACKET )? + ( END_TIMESTAMP EQ string )? + )? + ( + notify_users + ( TRIGGERS triggerDefinition (COMMA triggerDefinition)* )? + )? + ; + +alter_role + : ALTER ROLE if_exists? id_ RENAME TO id_ + | ALTER ROLE if_exists? id_ SET comment_clause + | ALTER ROLE if_exists? id_ UNSET COMMENT + | ALTER ROLE if_exists? id_ set_tags + | ALTER ROLE if_exists? id_ unset_tags + ; + +alter_row_access_policy + : ALTER ROW ACCESS POLICY if_exists? id_ SET BODY ARROW expr + | ALTER ROW ACCESS POLICY if_exists? id_ RENAME TO id_ + | ALTER ROW ACCESS POLICY if_exists? id_ SET comment_clause + ; + +alter_schema + : ALTER SCHEMA if_exists? schema_name RENAME TO schema_name + | ALTER SCHEMA if_exists? schema_name SWAP WITH schema_name + | ALTER SCHEMA if_exists? schema_name SET ( + ( DATA_RETENTION_TIME_IN_DAYS EQ num )? + ( MAX_DATA_EXTENSION_TIME_IN_DAYS EQ num )? + default_ddl_collation? + comment_clause? + ) + | ALTER SCHEMA if_exists? schema_name set_tags + | ALTER SCHEMA if_exists? schema_name unset_tags + | ALTER SCHEMA if_exists? schema_name UNSET schema_property (COMMA schema_property)* + | ALTER SCHEMA if_exists? schema_name ( ENABLE | DISABLE) MANAGED ACCESS + ; + +schema_property + : DATA_RETENTION_TIME_IN_DAYS + | MAX_DATA_EXTENSION_TIME_IN_DAYS + | DEFAULT_DDL_COLLATION_ + | COMMENT + ; + +alter_security_integration + : ALTER SEQUENCE if_exists? object_name RENAME TO object_name + | ALTER SEQUENCE if_exists? object_name SET? ( INCREMENT BY? EQ? num )? + | ALTER SEQUENCE if_exists? object_name SET comment_clause + | ALTER SEQUENCE if_exists? object_name UNSET COMMENT + ; + +alter_security_integration_external_oauth + : ALTER SECURITY? INTEGRATION if_exists id_ SET + ( TYPE EQ EXTERNAL_OAUTH )? + ( ENABLED EQ true_false )? + ( EXTERNAL_OAUTH_TYPE EQ ( OKTA | AZURE | PING_FEDERATE | CUSTOM ) )? + ( EXTERNAL_OAUTH_ISSUER EQ string )? + ( EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM EQ (string | '(' string_list ')') )? + ( EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE EQ string )? + ( EXTERNAL_OAUTH_JWS_KEYS_URL EQ string )? // For OKTA | PING_FEDERATE | CUSTOM + ( EXTERNAL_OAUTH_JWS_KEYS_URL EQ (string | '(' string_list ')') )? // For Azure + ( EXTERNAL_OAUTH_RSA_PUBLIC_KEY EQ string )? + ( EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2 EQ string )? + ( EXTERNAL_OAUTH_BLOCKED_ROLES_LIST EQ '(' string_list ')' )? + ( EXTERNAL_OAUTH_ALLOWED_ROLES_LIST EQ '(' string_list ')' )? + ( EXTERNAL_OAUTH_AUDIENCE_LIST EQ '(' string ')' )? + ( EXTERNAL_OAUTH_ANY_ROLE_MODE EQ (DISABLE | ENABLE | ENABLE_FOR_PRIVILEGE) )? + ( EXTERNAL_OAUTH_ANY_ROLE_MODE EQ string )? // Only for EXTERNAL_OAUTH_TYPE EQ CUSTOM + | ALTER SECURITY? INTEGRATION if_exists? id_ UNSET security_integration_external_oauth_property (COMMA security_integration_external_oauth_property)* + | ALTER SECURITY? INTEGRATION id_ set_tags + | ALTER SECURITY? INTEGRATION id_ unset_tags + ; + +security_integration_external_oauth_property + : ENABLED + | NETWORK_POLICY + | OAUTH_CLIENT_RSA_PUBLIC_KEY + | OAUTH_CLIENT_RSA_PUBLIC_KEY_2 + | OAUTH_USE_SECONDARY_ROLES EQ (IMPLICIT | NONE) + | COMMENT + ; + +alter_security_integration_snowflake_oauth + : ALTER SECURITY? INTEGRATION if_exists? id_ SET + ( TYPE EQ EXTERNAL_OAUTH )? + enabled_true_false? + ( EXTERNAL_OAUTH_TYPE EQ ( OKTA | AZURE | PING_FEDERATE | CUSTOM ) )? + ( EXTERNAL_OAUTH_ISSUER EQ string )? + ( EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM EQ (string | '(' string_list ')') )? + ( EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE EQ string )? + ( EXTERNAL_OAUTH_JWS_KEYS_URL EQ string )? // For OKTA | PING_FEDERATE | CUSTOM + ( EXTERNAL_OAUTH_JWS_KEYS_URL EQ ( string | '(' string_list ')' ) )? // For Azure + ( EXTERNAL_OAUTH_RSA_PUBLIC_KEY EQ string )? + ( EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2 EQ string )? + ( EXTERNAL_OAUTH_BLOCKED_ROLES_LIST EQ '(' string_list ')' )? + ( EXTERNAL_OAUTH_ALLOWED_ROLES_LIST EQ '(' string_list ')' )? + ( EXTERNAL_OAUTH_AUDIENCE_LIST EQ '(' string ')' )? + ( EXTERNAL_OAUTH_ANY_ROLE_MODE EQ DISABLE | ENABLE | ENABLE_FOR_PRIVILEGE )? + ( EXTERNAL_OAUTH_SCOPE_DELIMITER EQ string ) // Only for EXTERNAL_OAUTH_TYPE EQ CUSTOM + | ALTER SECURITY? INTEGRATION if_exists? id_ UNSET security_integration_snowflake_oauth_property (COMMA security_integration_snowflake_oauth_property)* + | ALTER SECURITY? INTEGRATION id_ set_tags + | ALTER SECURITY? INTEGRATION id_ unset_tags + ; + +security_integration_snowflake_oauth_property + : ENABLED + | EXTERNAL_OAUTH_AUDIENCE_LIST + ; + +alter_security_integration_saml2 + : ALTER SECURITY? INTEGRATION if_exists? id_ SET + ( TYPE EQ SAML2 )? + enabled_true_false? + ( SAML2_ISSUER EQ string )? + ( SAML2_SSO_URL EQ string )? + ( SAML2_PROVIDER EQ string )? + ( SAML2_X509_CERT EQ string )? + ( SAML2_SP_INITIATED_LOGIN_PAGE_LABEL EQ string )? + ( SAML2_ENABLE_SP_INITIATED EQ true_false )? + ( SAML2_SNOWFLAKE_X509_CERT EQ string )? + ( SAML2_SIGN_REQUEST EQ true_false )? + ( SAML2_REQUESTED_NAMEID_FORMAT EQ string )? + ( SAML2_POST_LOGOUT_REDIRECT_URL EQ string )? + ( SAML2_FORCE_AUTHN EQ true_false )? + ( SAML2_SNOWFLAKE_ISSUER_URL EQ string )? + ( SAML2_SNOWFLAKE_ACS_URL EQ string )? + | ALTER SECURITY? INTEGRATION if_exists? id_ UNSET ENABLED + | ALTER SECURITY? INTEGRATION id_ set_tags + | ALTER SECURITY? INTEGRATION id_ unset_tags + ; + +alter_security_integration_scim + : ALTER SECURITY? INTEGRATION if_exists? id_ SET + ( NETWORK_POLICY EQ string )? + ( SYNC_PASSWORD EQ true_false )? + comment_clause? + | ALTER SECURITY? INTEGRATION if_exists? id_ UNSET security_integration_scim_property (COMMA security_integration_scim_property)* + | ALTER SECURITY? INTEGRATION id_ set_tags + | ALTER SECURITY? INTEGRATION id_ unset_tags + ; + +security_integration_scim_property + : NETWORK_POLICY + | SYNC_PASSWORD + | COMMENT + ; + +alter_sequence + : ALTER SEQUENCE if_exists? id_ RENAME TO id_ + | ALTER SEQUENCE if_exists? id_ SET? ( INCREMENT BY? EQ? num )? + | ALTER SEQUENCE if_exists? id_ SET comment_clause + | ALTER SEQUENCE if_exists? id_ UNSET COMMENT + ; + +alter_session + : ALTER SESSION SET session_params + | ALTER SESSION UNSET param_name (COMMA param_name)* + ; + +alter_session_policy + : ALTER SESSION POLICY if_exists? id_ (UNSET | SET) ( SESSION_IDLE_TIMEOUT_MINS EQ num )? + ( SESSION_UI_IDLE_TIMEOUT_MINS EQ num )? + comment_clause? + | ALTER SESSION POLICY if_exists? id_ RENAME TO id_ + ; + +alter_share + : ALTER SHARE if_exists? id_ ( ADD | REMOVE ) ACCOUNTS EQ id_ (COMMA id_)* ( SHARE_RESTRICTIONS EQ true_false )? + | ALTER SHARE if_exists? id_ ADD ACCOUNTS EQ id_ (COMMA id_)* ( SHARE_RESTRICTIONS EQ true_false )? + | ALTER SHARE if_exists? id_ SET (ACCOUNTS EQ id_ (COMMA id_)* )? comment_clause? + | ALTER SHARE if_exists? id_ set_tags + | ALTER SHARE id_ unset_tags + | ALTER SHARE if_exists? id_ UNSET COMMENT + ; + +alter_stage + : ALTER STAGE if_exists? id_ RENAME TO id_ + | ALTER STAGE if_exists? id_ set_tags + | ALTER STAGE id_ unset_tags + // Internal stage + | ALTER STAGE if_exists? id_ SET ( + internal_stage_params? + file_format? + ( COPY_OPTIONS_ EQ '(' copy_options ')' )? + comment_clause + ) + // External stage + | ALTER STAGE if_exists? id_ SET ( + external_stage_params? + file_format? + ( COPY_OPTIONS_ EQ '(' copy_options ')' )? + comment_clause? + ) + ; + +alter_storage_integration + : ALTER STORAGE? INTEGRATION if_exists? id_ SET + cloud_provider_params2? + enabled_true_false? + ( STORAGE_ALLOWED_LOCATIONS EQ '(' string_list ')' )? + ( STORAGE_BLOCKED_LOCATIONS EQ '(' string_list ')' )? + comment_clause? + | ALTER STORAGE? INTEGRATION if_exists? id_ set_tags + | ALTER STORAGE? INTEGRATION id_ unset_tags + | ALTER STORAGE? INTEGRATION if_exists? id_ UNSET ( + ENABLED | + STORAGE_BLOCKED_LOCATIONS | + COMMENT + ) + //[ , ... ] + ; + +alter_stream + : ALTER STREAM if_exists? id_ SET + tag_decl_list? + comment_clause? + | ALTER STREAM if_exists? id_ set_tags + | ALTER STREAM id_ unset_tags + | ALTER STREAM if_exists? id_ UNSET COMMENT + ; + +alter_table + : ALTER TABLE if_exists? object_name RENAME TO object_name + | ALTER TABLE if_exists? object_name SWAP WITH object_name + | ALTER TABLE if_exists? object_name ( clustering_action | table_column_action | constraint_action ) + | ALTER TABLE if_exists? object_name ext_table_column_action + | ALTER TABLE if_exists? object_name search_optimization_action + | ALTER TABLE if_exists? object_name SET + stage_file_format? + ( STAGE_COPY_OPTIONS EQ '(' copy_options ')' )? + ( DATA_RETENTION_TIME_IN_DAYS EQ num )? + ( MAX_DATA_EXTENSION_TIME_IN_DAYS EQ num )? + ( CHANGE_TRACKING EQ true_false )? + default_ddl_collation? + comment_clause? + | ALTER TABLE if_exists? object_name set_tags + | ALTER TABLE if_exists? object_name unset_tags + | ALTER TABLE if_exists? object_name UNSET ( + DATA_RETENTION_TIME_IN_DAYS | + MAX_DATA_EXTENSION_TIME_IN_DAYS | + CHANGE_TRACKING | + DEFAULT_DDL_COLLATION_ | + COMMENT | + ) + //[ , ... ] + | ALTER TABLE if_exists? object_name ADD ROW ACCESS POLICY id_ ON column_list_in_parentheses + | ALTER TABLE if_exists? object_name DROP ROW ACCESS POLICY id_ + | ALTER TABLE if_exists? object_name DROP ROW ACCESS POLICY id_ COMMA ADD ROW ACCESS POLICY id_ ON column_list_in_parentheses + | ALTER TABLE if_exists? object_name DROP ALL ROW ACCESS POLICIES + ; + +clustering_action + : CLUSTER BY '(' expr_list ')' + | RECLUSTER ( MAX_SIZE EQ num )? ( WHERE expr )? + | resume_suspend RECLUSTER + | DROP CLUSTERING KEY + ; + +table_column_action + : ADD COLUMN? column_name data_type + ( DEFAULT expr | ( AUTOINCREMENT | IDENTITY ) ( '(' num COMMA num ')' | START num INCREMENT num )? )? + null_not_null? inline_constraint? + ( WITH? MASKING POLICY id_ ( USING '(' column_name COMMA column_list ')' )? )? + | RENAME COLUMN column_name TO column_name + | alter_modify '('? + COLUMN? column_name DROP DEFAULT + COMMA COLUMN? column_name SET DEFAULT object_name DOT NEXTVAL + COMMA COLUMN? column_name ( SET? NOT NULL_ | DROP NOT NULL_ ) + COMMA COLUMN? column_name ( ( SET DATA )? TYPE )? data_type + COMMA COLUMN? column_name comment_clause + COMMA COLUMN? column_name UNSET COMMENT + // [ COMMA COLUMN? column_name ... ] + // [ , ... ] + ')'? + | alter_modify COLUMN column_name SET MASKING POLICY id_ ( USING '(' column_name COMMA column_list ')' )? + FORCE? + | alter_modify COLUMN column_name UNSET MASKING POLICY + | alter_modify column_set_tags (COMMA column_set_tags)* + | alter_modify column_unset_tags (COMMA column_unset_tags)* + | DROP COLUMN? column_list + ; + +inline_constraint : + null_not_null? + ( CONSTRAINT id_ )? + ( UNIQUE | PRIMARY KEY | ( ( FOREIGN KEY )? REFERENCES object_name ( '(' column_name ')' )? ) ) + constraint_properties? + ; + +constraint_properties + : NOT? ENFORCED + | NOT? DEFERRABLE + | INITIALLY ( DEFERRED | IMMEDIATE ) + | MATCH ( FULL | PARTIAL | SIMPLE ) + | UPDATE ( CASCADE | SET NULL_ | SET DEFAULT | RESTRICT | NO ACTION ) + | DELETE ( CASCADE | SET NULL_ | SET DEFAULT | RESTRICT | NO ACTION ) + | ENABLE + | DISABLE + | VALIDATE + | NOVALIDATE + | RELY + | NORELY + ; + +ext_table_column_action + : ADD COLUMN? column_name data_type AS '(' expr ')' + | RENAME COLUMN column_name TO column_name + | DROP COLUMN? column_list + ; + +constraint_action + : ADD out_of_line_constraint + | RENAME CONSTRAINT id_ TO id_ + | alter_modify ( CONSTRAINT id_ | PRIMARY KEY | UNIQUE | FOREIGN KEY ) column_list_in_parentheses + ( NOT? ENFORCED )? ( VALIDATE | NOVALIDATE ) ( RELY | NORELY ) + | DROP ( CONSTRAINT id_ | PRIMARY KEY | UNIQUE | FOREIGN KEY ) column_list_in_parentheses + cascade_restrict? + ; + +search_optimization_action + : ADD SEARCH OPTIMIZATION ( + ON search_method_with_target (COMMA search_method_with_target )* + )? + | DROP SEARCH OPTIMIZATION ( + ON search_method_with_target (COMMA search_method_with_target )* + )? + ; + +search_method_with_target + : (EQUALITY | SUBSTRING | GEO) '(' (STAR | expr) ')' + ; + +alter_table_alter_column + : ALTER TABLE object_name alter_modify ('(' alter_column_decl_list ')' | alter_column_decl_list ) + | ALTER TABLE object_name alter_modify COLUMN column_name SET MASKING POLICY id_ ( USING '(' column_name COMMA column_list ')' )? FORCE? + | ALTER TABLE object_name alter_modify COLUMN column_name UNSET MASKING POLICY + | ALTER TABLE object_name alter_modify column_set_tags (COMMA column_set_tags)* + | ALTER TABLE object_name alter_modify column_unset_tags (COMMA column_unset_tags)* + ; + +alter_column_decl_list + : alter_column_decl (COMMA alter_column_decl)* + ; + +alter_column_decl + : COLUMN? column_name alter_column_opts + ; + +alter_column_opts + : DROP DEFAULT + | SET DEFAULT object_name DOT NEXTVAL + | ( SET? NOT NULL_ | DROP NOT NULL_ ) + | ( (SET DATA)? TYPE )? data_type + | comment_clause + | UNSET COMMENT + ; + +column_set_tags + : COLUMN? column_name set_tags + ; + +column_unset_tags + : COLUMN column_name unset_tags + ; + +alter_tag + : ALTER TAG alter_tag_opts + ; + +alter_task + : ALTER TASK if_exists? id_ resume_suspend + | ALTER TASK if_exists? id_ REMOVE AFTER string_list | ADD AFTER string_list + | ALTER TASK if_exists? id_ SET + ( WAREHOUSE EQ string )? + ( SCHEDULE EQ string )? + ( ALLOW_OVERLAPPING_EXECUTION EQ true_false )? + ( USER_TASK_TIMEOUT_MS EQ num )? + ( SUSPEND_TASK_AFTER_NUM_FAILURES EQ num )? + comment_clause? + session_parameter_init_list? + | ALTER TASK if_exists? id_ UNSET + WAREHOUSE? + SCHEDULE? + ALLOW_OVERLAPPING_EXECUTION? + USER_TASK_TIMEOUT_MS? + SUSPEND_TASK_AFTER_NUM_FAILURES? + COMMENT? + session_parameter_list? + //[ , ... ] + | ALTER TASK if_exists? id_ set_tags + | ALTER TASK if_exists? id_ unset_tags + | ALTER TASK if_exists? id_ MODIFY AS sql + | ALTER TASK if_exists? id_ MODIFY WHEN expr + ; + +alter_user + : ALTER USER if_exists? id_ alter_user_opts + ; + +alter_view + : ALTER VIEW if_exists? id_ RENAME TO id_ + | ALTER VIEW if_exists? id_ SET comment_clause + | ALTER VIEW if_exists? id_ UNSET COMMENT + | ALTER VIEW id_ SET SECURE + | ALTER VIEW id_ UNSET SECURE + | ALTER VIEW if_exists? id_ set_tags + | ALTER VIEW if_exists? id_ unset_tags + | ALTER VIEW if_exists? id_ ADD ROW ACCESS POLICY id_ ON column_list_in_parentheses + | ALTER VIEW if_exists? id_ DROP ROW ACCESS POLICY id_ + | ALTER VIEW if_exists? id_ ADD ROW ACCESS POLICY id_ ON column_list_in_parentheses COMMA DROP ROW ACCESS POLICY id_ + | ALTER VIEW if_exists? id_ DROP ALL ROW ACCESS POLICIES + | ALTER VIEW id_ alter_modify COLUMN? id_ SET MASKING POLICY id_ ( USING '(' column_name COMMA column_list ')' )? + FORCE? + | ALTER VIEW id_ alter_modify COLUMN? id_ UNSET MASKING POLICY + | ALTER VIEW id_ alter_modify COLUMN? id_ set_tags + | ALTER VIEW id_ alter_modify COLUMN id_ unset_tags + ; + +alter_modify + : ALTER | MODIFY + ; + +alter_warehouse + : ALTER WAREHOUSE if_exists? alter_warehouse_opts + ; + +alter_connection_opts + : id_ ENABLE FAILOVER TO ACCOUNTS id_ DOT id_ ( COMMA id_ DOT id_ )* ignore_edition_check? + | id_ DISABLE FAILOVER ( TO ACCOUNTS id_ DOT id_ (COMMA id_ DOT id_) )? + | id_ PRIMARY + | if_exists? id_ SET comment_clause + | if_exists? id_ UNSET COMMENT + ; + +alter_user_opts + : RENAME TO id_ + | RESET PASSWORD + | ABORT ALL QUERIES + | ADD DELEGATED AUTHORIZATION OF ROLE id_ TO SECURITY INTEGRATION id_ + | REMOVE DELEGATED ( AUTHORIZATION OF ROLE id_ | AUTHORIZATIONS ) FROM SECURITY INTEGRATION id_ + | set_tags + | unset_tags +// | SET object_properties? object_params? session_params? +// | UNSET (object_property_name | object_param_name | session_param_name) //[ , ... ] + ; + +alter_tag_opts + : if_exists? id_ RENAME TO id_ + | if_exists? id_ ( ADD | DROP ) ALLOWED_VALUES string (COMMA string)* + | id_ UNSET ALLOWED_VALUES + | id_ SET MASKING POLICY id_ (COMMA MASKING POLICY id_)* + | id_ UNSET MASKING POLICY id_ (COMMA MASKING POLICY id_)* + | if_exists? id_ SET comment_clause + | if_exists? id_ UNSET COMMENT + ; + +alter_network_policy_opts + : if_exists? id_ SET + (ALLOWED_IP_LIST EQ '(' string_list ')' )? + (BLOCKED_IP_LIST EQ '(' string_list ')' )? + comment_clause? + | if_exists? id_ UNSET COMMENT + | id_ RENAME TO id_ + ; + +alter_warehouse_opts + : id_? ( SUSPEND | RESUME if_suspended? ) + | id_? ABORT ALL QUERIES + | id_ RENAME TO id_ +// | id_ SET [ objectProperties ] + | id_ set_tags + | id_ unset_tags + | id_ UNSET id_ (COMMA id_)* + ; + +alter_account_opts + : SET account_params? object_params? session_params? + | UNSET param_name (COMMA param_name)? + | SET RESOURCE_MONITOR EQ id_ + | set_tags + | unset_tags + | id_ RENAME TO id_ ( SAVE_OLD_URL EQ true_false )? + | id_ DROP OLD URL + ; + +set_tags + : SET tag_decl_list + ; + +tag_decl_list + : TAG id_ EQ tag_value (COMMA id_ EQ tag_value )* + ; + +unset_tags + : UNSET TAG id_ (COMMA id_)* + ; + +// create commands +create_command + : create_account + | create_alert + | create_api_integration + | create_object_clone + | create_connection + | create_database + | create_dynamic_table + | create_external_function + | create_external_table + | create_failover_group + | create_file_format + | create_function + //| create_integration + | create_managed_account + | create_masking_policy + | create_materialized_view + | create_network_policy + | create_notification_integration + | create_pipe + | create_procedure + | create_replication_group + | create_resource_monitor + | create_role + | create_row_access_policy + | create_schema + | create_security_integration_external_oauth + | create_security_integration_snowflake_oauth + | create_security_integration_saml2 + | create_security_integration_scim + | create_sequence + | create_session_policy + | create_share + | create_stage + | create_storage_integration + | create_stream + | create_table + | create_table_as_select + // | create_|_alter_table_…_constraint + | create_tag + | create_task + | create_user + | create_view + | create_warehouse + ; + +create_account + : CREATE ACCOUNT id_ + ADMIN_NAME EQ id_ + ADMIN_PASSWORD EQ string + ( FIRST_NAME EQ id_ )? + ( LAST_NAME EQ id_ )? + EMAIL EQ string + ( MUST_CHANGE_PASSWORD EQ true_false )? + EDITION EQ ( STANDARD | ENTERPRISE | BUSINESS_CRITICAL ) + ( REGION_GROUP EQ region_group_id )? + ( REGION EQ snowflake_region_id )? + comment_clause? + ; + +create_alert + : CREATE or_replace? ALERT if_not_exists? id_ + WAREHOUSE EQ id_ + SCHEDULE EQ string + IF '(' EXISTS '(' alert_condition ')' ')' + THEN alert_action + ; + +alert_condition + : select_statement + | show_command + | call + ; + +alert_action + : sql_command + ; + +create_api_integration + : CREATE or_replace? API INTEGRATION if_not_exists? id_ + API_PROVIDER EQ ( id_ ) + API_AWS_ROLE_ARN EQ string + ( API_KEY EQ string )? + API_ALLOWED_PREFIXES EQ LR_BRACKET string RR_BRACKET + ( API_BLOCKED_PREFIXES EQ LR_BRACKET string RR_BRACKET )? + ENABLED EQ true_false + comment_clause? + | CREATE or_replace? API INTEGRATION if_not_exists? id_ + API_PROVIDER EQ id_ + AZURE_TENANT_ID EQ string + AZURE_AD_APPLICATION_ID EQ string + ( API_KEY EQ string )? + API_ALLOWED_PREFIXES EQ '(' string ')' + ( API_BLOCKED_PREFIXES EQ '(' string ')' )? + ENABLED EQ true_false + comment_clause? + | CREATE or_replace API INTEGRATION if_not_exists id_ + API_PROVIDER EQ id_ + GOOGLE_AUDIENCE EQ string + API_ALLOWED_PREFIXES EQ '(' string ')' + ( API_BLOCKED_PREFIXES EQ '(' string ')' )? + ENABLED EQ true_false + comment_clause? + ; + +create_object_clone + : CREATE or_replace? ( DATABASE | SCHEMA | TABLE ) if_not_exists? id_ + CLONE object_name + ( at_before1 LR_BRACKET ( TIMESTAMP ASSOC string | OFFSET ASSOC string | STATEMENT ASSOC id_ ) RR_BRACKET )? + | CREATE or_replace? ( STAGE | FILE FORMAT | SEQUENCE | STREAM | TASK ) if_not_exists? object_name + CLONE object_name + ; + +create_connection + : CREATE CONNECTION if_not_exists? id_ ( comment_clause? | (AS REPLICA OF id_ DOT id_ DOT id_ comment_clause?) ) + ; + +create_database + : CREATE or_replace? TRANSIENT? DATABASE if_not_exists? id_ + clone_at_before? + ( DATA_RETENTION_TIME_IN_DAYS EQ num )? + ( MAX_DATA_EXTENSION_TIME_IN_DAYS EQ num )? + default_ddl_collation? + with_tags? + comment_clause? + ; + +create_dynamic_table + : CREATE or_replace? DYNAMIC TABLE id_ + TARGET_LAG EQ (string | DOWNSTREAM) + WAREHOUSE EQ wh=id_ + AS query_statement + ; + +clone_at_before + : CLONE id_ ( at_before1 LR_BRACKET ( TIMESTAMP ASSOC string | OFFSET ASSOC string | STATEMENT ASSOC id_ ) RR_BRACKET )? + ; + +at_before1 + : AT_KEYWORD | BEFORE + ; + +header_decl + : string EQ string + ; + +compression_type + : NONE + | GZIP + | DEFLATE + | AUTO + ; + +compression + : COMPRESSION EQ compression_type + ; + +create_external_function + : CREATE or_replace? SECURE? EXTERNAL FUNCTION object_name LR_BRACKET ( arg_name arg_data_type (COMMA arg_name arg_data_type)* )? RR_BRACKET + RETURNS data_type + null_not_null? + ( ( CALLED ON NULL_ INPUT) | ((RETURNS NULL_ ON NULL_ INPUT) | STRICT) )? + ( VOLATILE | IMMUTABLE )? + comment_clause? + API_INTEGRATION EQ id_ + ( HEADERS EQ LR_BRACKET header_decl (COMMA header_decl)* RR_BRACKET )? + ( CONTEXT_HEADERS EQ LR_BRACKET id_ (COMMA id_)* RR_BRACKET )? + ( MAX_BATCH_ROWS EQ num )? + compression? + ( REQUEST_TRANSLATOR EQ id_ )? + ( RESPONSE_TRANSLATOR EQ id_ )? + AS string + ; + +create_external_table + // Partitions computed from expressions + : CREATE or_replace? EXTERNAL TABLE if_not_exists? + object_name '(' external_table_column_decl_list ')' + cloud_provider_params3? + partition_by? + WITH? LOCATION EQ external_stage + ( REFRESH_ON_CREATE EQ true_false )? + ( AUTO_REFRESH EQ true_false )? + pattern? + file_format + ( AWS_SNS_TOPIC EQ string )? + copy_grants? + with_row_access_policy? + with_tags? + comment_clause? + // Partitions added and removed manually + | CREATE or_replace? EXTERNAL TABLE if_not_exists? + object_name '(' external_table_column_decl_list ')' + cloud_provider_params3? + partition_by? + WITH? LOCATION EQ external_stage + PARTITION_TYPE EQ USER_SPECIFIED + file_format + copy_grants? + with_row_access_policy? + with_tags? + comment_clause? + // Delta Lake + | CREATE or_replace? EXTERNAL TABLE if_not_exists? + object_name '(' external_table_column_decl_list ')' + cloud_provider_params3? + partition_by? + WITH? LOCATION EQ external_stage + PARTITION_TYPE EQ USER_SPECIFIED + file_format + ( TABLE_FORMAT EQ DELTA )? + copy_grants? + with_row_access_policy? + with_tags? + comment_clause? + ; + +external_table_column_decl + : column_name data_type AS (expr | id_) inline_constraint? + ; + +external_table_column_decl_list + : external_table_column_decl (COMMA external_table_column_decl)* + ; + +full_acct + : id_ DOT id_ + ; + +integration_type_name + : SECURITY INTEGRATIONS | API INTEGRATIONS + ; + +create_failover_group + : CREATE FAILOVER GROUP if_not_exists? id_ + OBJECT_TYPES EQ object_type (COMMA object_type )* + ( ALLOWED_DATABASES EQ id_ (COMMA id_ )* )? + ( ALLOWED_SHARES EQ id_ (COMMA id_)* )? + ( ALLOWED_INTEGRATION_TYPES EQ integration_type_name (COMMA integration_type_name)* )? + ALLOWED_ACCOUNTS EQ full_acct (COMMA full_acct)* + ( IGNORE EDITION CHECK )? + ( REPLICATION_SCHEDULE EQ string )? +// Secondary Replication Group + | CREATE FAILOVER GROUP if_not_exists? id_ + AS REPLICA OF id_ DOT id_ DOT id_ + ; + +type_fileformat + : CSV + | JSON + | AVRO + | ORC + | PARQUET + | XML + | CSV_Q + | JSON_Q + | AVRO_Q + | ORC_Q + | PARQUET_Q + | XML_Q + ; + +create_file_format + : CREATE or_replace? FILE FORMAT if_not_exists? object_name + (TYPE EQ type_fileformat)? format_type_options* + comment_clause? + ; + +arg_decl + : arg_name arg_data_type + ; + +col_decl + : column_name data_type + ; + +function_definition + : string + | DBL_DOLLAR + ; + +create_function + : CREATE or_replace? SECURE? FUNCTION object_name LR_BRACKET ( arg_decl (COMMA arg_decl)* )? RR_BRACKET + RETURNS ( data_type | TABLE LR_BRACKET (col_decl (COMMA col_decl)* )? RR_BRACKET ) + null_not_null? + LANGUAGE JAVASCRIPT + ( CALLED ON NULL_ INPUT | RETURNS NULL_ ON NULL_ INPUT | STRICT )? + ( VOLATILE | IMMUTABLE )? + comment_clause? + AS function_definition + | CREATE or_replace? SECURE? FUNCTION object_name LR_BRACKET ( arg_decl (COMMA arg_decl)* )? RR_BRACKET + RETURNS ( data_type | TABLE LR_BRACKET (col_decl (COMMA col_decl)* )? RR_BRACKET ) + null_not_null? + ( CALLED ON NULL_ INPUT | RETURNS NULL_ ON NULL_ INPUT | STRICT )? + ( VOLATILE | IMMUTABLE )? + MEMOIZABLE? + comment_clause? + AS function_definition + ; + +create_managed_account + : CREATE MANAGED ACCOUNT id_ ADMIN_NAME EQ id_ COMMA ADMIN_PASSWORD EQ string COMMA TYPE EQ READER (COMMA comment_clause)? + ; + +create_masking_policy + : CREATE or_replace? MASKING POLICY if_not_exists? object_name AS + '(' arg_name arg_data_type (COMMA arg_name arg_data_type)? ')' + RETURNS arg_data_type ARROW expr + comment_clause? + ; + +tag_decl + : object_name EQ string + ; + +column_list_in_parentheses + : LR_BRACKET column_list RR_BRACKET + ; + +create_materialized_view + : CREATE or_replace? SECURE? MATERIALIZED VIEW if_not_exists? object_name + copy_grants? + column_list_in_parentheses? +// [ [ WITH ] MASKING POLICY [ USING ( , , ... ) ] +// [ WITH ] TAG ( = '' [ , = '' , ... ] ) ] +// [ , [ ... ] ] + with_row_access_policy? + with_tags? + comment_clause? + cluster_by? + AS select_statement + ; + +create_network_policy + : CREATE or_replace? NETWORK POLICY id_ + ALLOWED_IP_LIST EQ '(' string_list? ')' + ( BLOCKED_IP_LIST EQ '(' string_list? ')' )? + comment_clause? + ; + +cloud_provider_params_auto + //(for Google Cloud Storage) + : NOTIFICATION_PROVIDER EQ GCP_PUBSUB GCP_PUBSUB_SUBSCRIPTION_NAME EQ string + //(for Microsoft Azure Storage) + | NOTIFICATION_PROVIDER EQ AZURE_EVENT_GRID AZURE_STORAGE_QUEUE_PRIMARY_URI EQ string AZURE_TENANT_ID EQ string + ; + +cloud_provider_params_push + //(for Amazon SNS) + : NOTIFICATION_PROVIDER EQ AWS_SNS + AWS_SNS_TOPIC_ARN EQ string + AWS_SNS_ROLE_ARN EQ string + //(for Google Pub/Sub) + | NOTIFICATION_PROVIDER EQ GCP_PUBSUB + GCP_PUBSUB_TOPIC_NAME EQ string + //(for Microsoft Azure Event Grid) + | NOTIFICATION_PROVIDER EQ AZURE_EVENT_GRID + AZURE_EVENT_GRID_TOPIC_ENDPOINT EQ string + AZURE_TENANT_ID EQ string + ; + +create_notification_integration + : CREATE or_replace? NOTIFICATION INTEGRATION if_not_exists? id_ + ENABLED EQ true_false + TYPE EQ QUEUE + cloud_provider_params_auto + comment_clause? + | CREATE or_replace? NOTIFICATION INTEGRATION if_not_exists? id_ + ENABLED EQ true_false + DIRECTION EQ OUTBOUND + TYPE EQ QUEUE + cloud_provider_params_push + comment_clause? + ; + +create_pipe + : CREATE or_replace? PIPE if_not_exists? object_name + ( AUTO_INGEST EQ true_false )? + ( ERROR_INTEGRATION EQ id_ )? + ( AWS_SNS_TOPIC EQ string )? + ( INTEGRATION EQ string )? + comment_clause? + AS copy_into_table + ; + +caller_owner + : CALLER | OWNER + ; + +executa_as + : EXECUTE AS caller_owner + ; + +procedure_definition + : string + | DBL_DOLLAR + ; + +create_procedure + : CREATE or_replace? PROCEDURE object_name LR_BRACKET ( arg_decl (COMMA arg_decl)* )? RR_BRACKET + RETURNS ( data_type | TABLE LR_BRACKET ( col_decl (COMMA col_decl)* )? RR_BRACKET ) + ( NOT NULL_ )? + LANGUAGE SQL + ( CALLED ON NULL_ INPUT | RETURNS NULL_ ON NULL_ INPUT | STRICT )? + ( VOLATILE | IMMUTABLE )? // Note: VOLATILE and IMMUTABLE are deprecated. + comment_clause? + executa_as? + AS procedure_definition + | CREATE or_replace? SECURE? PROCEDURE object_name LR_BRACKET ( arg_decl (COMMA arg_decl)* )? RR_BRACKET + RETURNS data_type ( NOT NULL_ )? + LANGUAGE JAVASCRIPT + ( CALLED ON NULL_ INPUT | RETURNS NULL_ ON NULL_ INPUT | STRICT )? + ( VOLATILE | IMMUTABLE )? // Note: VOLATILE and IMMUTABLE are deprecated. + comment_clause? + executa_as? + AS procedure_definition + ; + +create_replication_group + : CREATE REPLICATION GROUP if_not_exists? id_ + OBJECT_TYPES EQ object_type ( COMMA object_type )* + ( ALLOWED_DATABASES EQ id_ (COMMA id_)* )? + ( ALLOWED_SHARES EQ id_ (COMMA id_ )* )? + ( ALLOWED_INTEGRATION_TYPES EQ integration_type_name (COMMA integration_type_name )* )? + ALLOWED_ACCOUNTS EQ full_acct (COMMA full_acct)* + ( IGNORE EDITION CHECK )? + ( REPLICATION_SCHEDULE EQ string )? + //Secondary Replication Group + | CREATE REPLICATION GROUP if_not_exists? id_ AS REPLICA OF id_ DOT id_ DOT id_ + ; + +create_resource_monitor + : CREATE or_replace? RESOURCE MONITOR id_ WITH + credit_quota? + frequency? + ( START_TIMESTAMP EQ ( string | IMMEDIATELY ) )? + ( END_TIMESTAMP EQ string )? + notify_users? + ( TRIGGERS trigger_definition+ )? + ; + +create_role + : CREATE or_replace? ROLE if_not_exists? id_ + ( WITH? TAG LR_BRACKET id_ EQ STRING ( COMMA id_ EQ STRING )* RR_BRACKET )? + ( COMMENT EQ STRING )? + ; + +create_row_access_policy + : CREATE or_replace? ROW ACCESS POLICY if_not_exists? id_ AS + LR_BRACKET arg_decl (COMMA arg_decl)* RR_BRACKET + RETURNS BOOLEAN ARROW expr + comment_clause? + ; + +create_schema + : CREATE or_replace? TRANSIENT? SCHEMA if_not_exists? schema_name + clone_at_before? + ( WITH MANAGED ACCESS )? + ( DATA_RETENTION_TIME_IN_DAYS EQ num )? + ( MAX_DATA_EXTENSION_TIME_IN_DAYS EQ num )? + default_ddl_collation? + with_tags? + comment_clause? + ; + +create_security_integration_external_oauth + : CREATE or_replace? SECURITY INTEGRATION if_not_exists? id_ + TYPE EQ EXTERNAL_OAUTH + ENABLED EQ true_false + EXTERNAL_OAUTH_TYPE EQ ( OKTA | AZURE | PING_FEDERATE | CUSTOM ) + EXTERNAL_OAUTH_ISSUER EQ string + EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM EQ (string | '(' string_list ')' ) + EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE EQ string + ( EXTERNAL_OAUTH_JWS_KEYS_URL EQ string )? // For OKTA | PING_FEDERATE | CUSTOM + ( EXTERNAL_OAUTH_JWS_KEYS_URL EQ (string | '(' string_list ')') )? // For Azure + ( EXTERNAL_OAUTH_BLOCKED_ROLES_LIST EQ '(' string_list ')' )? + ( EXTERNAL_OAUTH_ALLOWED_ROLES_LIST EQ '(' string_list ')' )? + ( EXTERNAL_OAUTH_RSA_PUBLIC_KEY EQ string )? + ( EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2 EQ string )? + ( EXTERNAL_OAUTH_AUDIENCE_LIST EQ '(' string ')' )? + ( EXTERNAL_OAUTH_ANY_ROLE_MODE EQ (DISABLE | ENABLE | ENABLE_FOR_PRIVILEGE) )? + ( EXTERNAL_OAUTH_SCOPE_DELIMITER EQ string )? // Only for EXTERNAL_OAUTH_TYPE EQ CUSTOM + ; + +implicit_none + : IMPLICIT + | NONE + ; + +create_security_integration_snowflake_oauth + : CREATE or_replace? SECURITY INTEGRATION if_not_exists? id_ + TYPE EQ OAUTH + OAUTH_CLIENT EQ partner_application + OAUTH_REDIRECT_URI EQ string //Required when OAUTH_CLIENTEQLOOKER + enabled_true_false? + ( OAUTH_ISSUE_REFRESH_TOKENS EQ true_false )? + ( OAUTH_REFRESH_TOKEN_VALIDITY EQ num )? + ( OAUTH_USE_SECONDARY_ROLES EQ implicit_none )? + ( BLOCKED_ROLES_LIST EQ '(' string_list ')' )? + comment_clause? + // Snowflake OAuth for custom clients + | CREATE or_replace? SECURITY INTEGRATION if_not_exists? id_ + TYPE EQ OAUTH + OAUTH_CLIENT EQ CUSTOM + //OAUTH_CLIENT_TYPE EQ 'CONFIDENTIAL' | 'PUBLIC' + OAUTH_REDIRECT_URI EQ string + enabled_true_false? + ( OAUTH_ALLOW_NON_TLS_REDIRECT_URI EQ true_false )? + ( OAUTH_ENFORCE_PKCE EQ true_false )? + ( OAUTH_USE_SECONDARY_ROLES EQ implicit_none )? + ( PRE_AUTHORIZED_ROLES_LIST EQ '(' string_list ')' )? + ( BLOCKED_ROLES_LIST EQ '(' string_list ')' )? + ( OAUTH_ISSUE_REFRESH_TOKENS EQ true_false )? + ( OAUTH_REFRESH_TOKEN_VALIDITY EQ num )? + network_policy? + ( OAUTH_CLIENT_RSA_PUBLIC_KEY EQ string )? + ( OAUTH_CLIENT_RSA_PUBLIC_KEY_2 EQ string )? + comment_clause? + ; + +create_security_integration_saml2 + : CREATE or_replace? SECURITY INTEGRATION if_not_exists? + TYPE EQ SAML2 + enabled_true_false + SAML2_ISSUER EQ string + SAML2_SSO_URL EQ string + SAML2_PROVIDER EQ string + SAML2_X509_CERT EQ string + ( SAML2_SP_INITIATED_LOGIN_PAGE_LABEL EQ string )? + ( SAML2_ENABLE_SP_INITIATED EQ true_false )? + ( SAML2_SNOWFLAKE_X509_CERT EQ string )? + ( SAML2_SIGN_REQUEST EQ true_false )? + ( SAML2_REQUESTED_NAMEID_FORMAT EQ string )? + ( SAML2_POST_LOGOUT_REDIRECT_URL EQ string )? + ( SAML2_FORCE_AUTHN EQ true_false )? + ( SAML2_SNOWFLAKE_ISSUER_URL EQ string )? + ( SAML2_SNOWFLAKE_ACS_URL EQ string )? + ; + +create_security_integration_scim + : CREATE or_replace? SECURITY INTEGRATION if_not_exists? + id_ + TYPE EQ SCIM + SCIM_CLIENT EQ (OKTA_Q | AZURE_Q | GENERIC_Q) + RUN_AS_ROLE EQ (OKTA_PROVISIONER_Q | AAD_PROVISIONER_Q | GENERIC_SCIM_PROVISIONER_Q) + network_policy? + ( SYNC_PASSWORD EQ true_false )? + comment_clause? + ; + +network_policy + : NETWORK_POLICY EQ string + ; + +partner_application + : TABLEAU_DESKTOP + | TABLEAU_SERVER + | LOOKER + ; + +start_with + : START WITH? EQ? num + ; + +increment_by + : INCREMENT BY? EQ? num + ; + +create_sequence + : CREATE or_replace? SEQUENCE if_not_exists? object_name + WITH? + start_with? + increment_by? + comment_clause? + ; + +create_session_policy + : CREATE or_replace? SESSION POLICY if_exists? id_ + (SESSION_IDLE_TIMEOUT_MINS EQ num)? + (SESSION_UI_IDLE_TIMEOUT_MINS EQ num)? + comment_clause? + ; + +create_share + : CREATE or_replace? SHARE id_ + comment_clause? + ; + +character + : CHAR_LITERAL + ; + +format_type_options + //-- If TYPE EQ CSV + : COMPRESSION EQ (AUTO | GZIP | BZ2 | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE | AUTO_Q ) + | RECORD_DELIMITER EQ ( string | NONE) + | FIELD_DELIMITER EQ ( string | NONE) + | FILE_EXTENSION EQ string + | SKIP_HEADER EQ num + | SKIP_BLANK_LINES EQ true_false + | DATE_FORMAT EQ (string | AUTO) + | TIME_FORMAT EQ (string | AUTO) + | TIMESTAMP_FORMAT EQ (string | AUTO) + | BINARY_FORMAT EQ (HEX | BASE64 | UTF8) + | ESCAPE EQ (character | NONE | NONE_Q ) + | ESCAPE_UNENCLOSED_FIELD EQ (string | NONE | NONE_Q ) + | TRIM_SPACE EQ true_false + | FIELD_OPTIONALLY_ENCLOSED_BY EQ (string | NONE | NONE_Q) + | NULL_IF EQ LR_BRACKET string_list RR_BRACKET + | ERROR_ON_COLUMN_COUNT_MISMATCH EQ true_false + | REPLACE_INVALID_CHARACTERS EQ true_false + | EMPTY_FIELD_AS_NULL EQ true_false + | SKIP_BYTE_ORDER_MARK EQ true_false + | ENCODING EQ (string | UTF8) //by the way other encoding keyword are valid ie WINDOWS1252 + //-- If TYPE EQ JSON + //| COMPRESSION EQ (AUTO | GZIP | BZ2 | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE) +// | DATE_FORMAT EQ string | AUTO +// | TIME_FORMAT EQ string | AUTO +// | TIMESTAMP_FORMAT EQ string | AUTO +// | BINARY_FORMAT EQ HEX | BASE64 | UTF8 +// | TRIM_SPACE EQ true_false +// | NULL_IF EQ LR_BRACKET string_list RR_BRACKET +// | FILE_EXTENSION EQ string + | ENABLE_OCTAL EQ true_false + | ALLOW_DUPLICATE EQ true_false + | STRIP_OUTER_ARRAY EQ true_false + | STRIP_NULL_VALUES EQ true_false +// | REPLACE_INVALID_CHARACTERS EQ true_false + | IGNORE_UTF8_ERRORS EQ true_false +// | SKIP_BYTE_ORDER_MARK EQ true_false + //-- If TYPE EQ AVRO +// | COMPRESSION EQ AUTO | GZIP | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE +// | TRIM_SPACE EQ true_false +// | NULL_IF EQ LR_BRACKET string_list RR_BRACKET + //-- If TYPE EQ ORC +// | TRIM_SPACE EQ true_false +// | NULL_IF EQ LR_BRACKET string_list RR_BRACKET + //-- If TYPE EQ PARQUET + | COMPRESSION EQ AUTO | LZO | SNAPPY | NONE + | SNAPPY_COMPRESSION EQ true_false + | BINARY_AS_TEXT EQ true_false +// | TRIM_SPACE EQ true_false +// | NULL_IF EQ LR_BRACKET string_list RR_BRACKET + //-- If TYPE EQ XML + | COMPRESSION EQ AUTO | GZIP | BZ2 | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE +// | IGNORE_UTF8_ERRORS EQ true_false + | PRESERVE_SPACE EQ true_false + | STRIP_OUTER_ELEMENT EQ true_false + | DISABLE_SNOWFLAKE_DATA EQ true_false + | DISABLE_AUTO_CONVERT EQ true_false +// | SKIP_BYTE_ORDER_MARK EQ true_false + ; + +copy_options + : ON_ERROR EQ ( CONTINUE | SKIP_FILE | SKIP_FILE_N | SKIP_FILE_N ABORT_STATEMENT ) + | SIZE_LIMIT EQ num + | PURGE EQ true_false + | RETURN_FAILED_ONLY EQ true_false + | MATCH_BY_COLUMN_NAME EQ CASE_SENSITIVE | CASE_INSENSITIVE | NONE + | ENFORCE_LENGTH EQ true_false + | TRUNCATECOLUMNS EQ true_false + | FORCE EQ true_false + ; + +internal_stage_params + : ENCRYPTION EQ LR_BRACKET TYPE EQ /*'SNOWFLAKE_FULL' */| TYPE EQ /*'SNOWFLAKE_SSE'*/ RR_BRACKET + ; + +stage_type + : TYPE EQ string + ; + +stage_master_key + : MASTER_KEY EQ string + ; + +stage_kms_key + : KMS_KEY_ID EQ string + ; + +stage_encryption_opts_aws + : ENCRYPTION EQ LR_BRACKET + (stage_type? stage_master_key | + stage_type? | + ( stage_type stage_kms_key? )? | stage_type? ) + RR_BRACKET + ; + +aws_token + : AWS_TOKEN EQ string + ; + +aws_key_id + : AWS_KEY_ID EQ string + ; + +aws_secret_key + : AWS_SECRET_KEY EQ string + ; + +aws_role + : AWS_ROLE EQ string + ; + +external_stage_params + //(for Amazon S3) + : URL EQ string_list + ( ( STORAGE_INTEGRATION EQ id_ ) + | ( CREDENTIALS EQ LR_BRACKET ( ( aws_key_id aws_secret_key aws_token? ) | aws_role ) RR_BRACKET ) + )? + stage_encryption_opts_aws? + //(for Google Cloud Storage) + | URL EQ string + ( STORAGE_INTEGRATION EQ id_ )? + ( ENCRYPTION EQ ( ( TYPE EQ /*'GCS_SSE_KMS'*/ )? ( KMS_KEY_ID EQ string )? | ( TYPE EQ 'NONE' )? ) )? + //(for Microsoft Azure) + | URL EQ string + ( ( STORAGE_INTEGRATION EQ id_ ) | ( CREDENTIALS EQ LR_BRACKET ( AZURE_SAS_TOKEN EQ string )? RR_BRACKET ) )? + ( ENCRYPTION EQ LR_BRACKET ( TYPE EQ /*'AZURE_CSE'*/ )? ( MASTER_KEY EQ string )? | ( TYPE EQ 'NONE' )? RR_BRACKET )? + ; + +true_false + : TRUE | FALSE + ; + +enable + : ENABLE EQ true_false + ; + +refresh_on_create + : REFRESH_ON_CREATE EQ true_false + ; + +auto_refresh + : AUTO_REFRESH EQ true_false + ; + +notification_integration + : NOTIFICATION_INTEGRATION EQ string + ; + +directory_table_params + //(for internal stages) + : DIRECTORY EQ LR_BRACKET enable refresh_on_create? RR_BRACKET +// (for Amazon S3) + | DIRECTORY EQ LR_BRACKET enable + refresh_on_create? + auto_refresh? RR_BRACKET +// (for Google Cloud Storage) + | DIRECTORY EQ LR_BRACKET enable + auto_refresh? + refresh_on_create? + notification_integration? RR_BRACKET +// (for Microsoft Azure) + | DIRECTORY EQ LR_BRACKET enable + refresh_on_create? + auto_refresh? + notification_integration? RR_BRACKET + ; + +create_stage + //Internal stage + : CREATE or_replace? TEMPORARY? STAGE if_not_exists? object_name + internal_stage_params? + directory_table_params? + ( FILE_FORMAT EQ LR_BRACKET ( FORMAT_NAME EQ string | TYPE EQ ( CSV | JSON | AVRO | ORC | PARQUET | XML ) format_type_options* ) RR_BRACKET )? + ( COPY_OPTIONS_ EQ LR_BRACKET copy_options RR_BRACKET )? + with_tags? + comment_clause? + //External stage + | CREATE or_replace? TEMPORARY? STAGE if_not_exists? object_name + external_stage_params + directory_table_params? + ( FILE_FORMAT EQ LR_BRACKET ( FORMAT_NAME EQ string | TYPE EQ ( CSV | JSON | AVRO | ORC | PARQUET | XML ) format_type_options* ) RR_BRACKET )? + ( COPY_OPTIONS_ EQ LR_BRACKET copy_options RR_BRACKET )? + with_tags? + comment_clause? + ; + +cloud_provider_params + //(for Amazon S3) + : STORAGE_PROVIDER EQ S3 STORAGE_AWS_ROLE_ARN EQ string ( STORAGE_AWS_OBJECT_ACL EQ string )? + //(for Google Cloud Storage) + | STORAGE_PROVIDER EQ GCS + //(for Microsoft Azure) + | STORAGE_PROVIDER EQ AZURE AZURE_TENANT_ID EQ string + ; + +cloud_provider_params2 + //(for Amazon S3) + : STORAGE_AWS_ROLE_ARN EQ string ( STORAGE_AWS_OBJECT_ACL EQ string )? + //(for Microsoft Azure) + | AZURE_TENANT_ID EQ string + ; + +cloud_provider_params3 + : INTEGRATION EQ string + ; + +create_storage_integration + : CREATE or_replace? STORAGE INTEGRATION if_not_exists? id_ + TYPE EQ EXTERNAL_STAGE + cloud_provider_params + ENABLED EQ true_false + STORAGE_ALLOWED_LOCATIONS EQ LR_BRACKET string_list RR_BRACKET + ( STORAGE_BLOCKED_LOCATIONS EQ LR_BRACKET string_list RR_BRACKET )? + comment_clause? + ; + +copy_grants + : COPY GRANTS + ; + +append_only + : APPEND_ONLY EQ true_false + ; + +insert_only + : INSERT_ONLY EQ TRUE + ; + +show_initial_rows + : SHOW_INITIAL_ROWS EQ true_false + ; + +stream_time + : at_before1 LR_BRACKET ( TIMESTAMP ASSOC string | OFFSET ASSOC string | STATEMENT ASSOC id_ | STREAM ASSOC string ) RR_BRACKET + ; + +create_stream + //-- table + : CREATE or_replace? STREAM if_not_exists? + object_name + copy_grants? + ON TABLE object_name + stream_time? + append_only? + show_initial_rows? + comment_clause? + //-- External table + | CREATE or_replace? STREAM if_not_exists? + object_name + copy_grants? + ON EXTERNAL TABLE object_name + stream_time? + insert_only? + comment_clause? + //-- Directory table + | CREATE or_replace? STREAM if_not_exists? + object_name + copy_grants? + ON STAGE object_name + comment_clause? + //-- View + | CREATE or_replace? STREAM if_not_exists? + object_name + copy_grants? + ON VIEW object_name + stream_time? + append_only? + show_initial_rows? + comment_clause? + ; + +temporary + : TEMP | TEMPORARY + ; + +table_type + : ( ( LOCAL | GLOBAL )? temporary | VOLATILE ) | TRANSIENT + ; + +with_tags + : WITH? TAG LR_BRACKET tag_decl (COMMA tag_decl)* RR_BRACKET + ; + +with_row_access_policy + : WITH? ROW ACCESS POLICY id_ ON LR_BRACKET column_name (COMMA column_name)* RR_BRACKET + ; + +cluster_by + : CLUSTER BY expr_list_in_parentheses + ; + +change_tracking + : CHANGE_TRACKING EQ true_false + ; + +with_masking_policy + : WITH? MASKING POLICY id_ ( USING column_list_in_parentheses )? + ; + +collate + : COLLATE string + ; + +not_null + : NOT NULL_ + ; + +default_value + : DEFAULT expr | (AUTOINCREMENT | IDENTITY) ( LR_BRACKET num COMMA num RR_BRACKET | start_with | increment_by | start_with increment_by )? + ; + +foreign_key + : FOREIGN KEY + ; + +out_of_line_constraint + : (CONSTRAINT id_ )? + ( + UNIQUE column_list_in_parentheses? + | PRIMARY KEY column_list_in_parentheses? + | foreign_key? column_list_in_parentheses? REFERENCES object_name column_list_in_parentheses? + ) + constraint_properties? + ; + + +full_col_decl + : col_decl + ( + collate + | inline_constraint + | default_value + | null_not_null + )* + with_masking_policy? + with_tags? + (COMMENT string)? + ; + +column_decl_item + : full_col_decl + | out_of_line_constraint + ; + +column_decl_item_list + : column_decl_item (COMMA column_decl_item)* + ; + +create_table + : CREATE or_replace? table_type? TABLE (if_not_exists? object_name | object_name if_not_exists? ) + '(' column_decl_item_list ')' + cluster_by? + stage_file_format? + ( STAGE_COPY_OPTIONS EQ LR_BRACKET copy_options RR_BRACKET )? + ( DATA_RETENTION_TIME_IN_DAYS EQ num )? + ( MAX_DATA_EXTENSION_TIME_IN_DAYS EQ num )? + change_tracking? + default_ddl_collation? + copy_grants? + with_row_access_policy? + with_tags? + comment_clause? + ; + +create_table_as_select + : CREATE or_replace? table_type? TABLE (if_not_exists? object_name | object_name if_not_exists? ) + ('(' column_decl_item_list ')')? + cluster_by? + copy_grants? + with_row_access_policy? + with_tags? + comment_clause? + AS select_statement + ; + +create_tag + : CREATE or_replace? TAG if_not_exists? id_ comment_clause? + | CREATE or_replace? TAG if_not_exists? id_ ( ALLOWED_VALUES string (COMMA string)* )? + ; + +session_parameter + : ABORT_DETACHED_QUERY + | ALLOW_CLIENT_MFA_CACHING + | ALLOW_ID_TOKEN + | AUTOCOMMIT + | AUTOCOMMIT_API_SUPPORTED + | BINARY_INPUT_FORMAT + | BINARY_OUTPUT_FORMAT + | CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS + | CLIENT_ENCRYPTION_KEY_SIZE + | CLIENT_MEMORY_LIMIT + | CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX + | CLIENT_METADATA_USE_SESSION_DATABASE + | CLIENT_PREFETCH_THREADS + | CLIENT_RESULT_CHUNK_SIZE + | CLIENT_RESULT_COLUMN_CASE_INSENSITIVE + | CLIENT_SESSION_KEEP_ALIVE + | CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY + | CLIENT_TIMESTAMP_TYPE_MAPPING + | DATA_RETENTION_TIME_IN_DAYS + | DATE_INPUT_FORMAT + | DATE_OUTPUT_FORMAT + | DEFAULT_DDL_COLLATION_ + | ENABLE_INTERNAL_STAGES_PRIVATELINK + | ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION + | ENFORCE_SESSION_POLICY + | ERROR_ON_NONDETERMINISTIC_MERGE + | ERROR_ON_NONDETERMINISTIC_UPDATE + | EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST + | GEOGRAPHY_OUTPUT_FORMAT + | GEOMETRY_OUTPUT_FORMAT + | INITIAL_REPLICATION_SIZE_LIMIT_IN_TB + | JDBC_TREAT_DECIMAL_AS_INT + | JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC + | JDBC_USE_SESSION_TIMEZONE + | JSON_INDENT + | JS_TREAT_INTEGER_AS_BIGINT + | LOCK_TIMEOUT + | MAX_CONCURRENCY_LEVEL + | MAX_DATA_EXTENSION_TIME_IN_DAYS + | MULTI_STATEMENT_COUNT + | MIN_DATA_RETENTION_TIME_IN_DAYS + | NETWORK_POLICY + | SHARE_RESTRICTIONS + | PERIODIC_DATA_REKEYING + | PIPE_EXECUTION_PAUSED + | PREVENT_UNLOAD_TO_INLINE_URL + | PREVENT_UNLOAD_TO_INTERNAL_STAGES + | QUERY_TAG + | QUOTED_IDENTIFIERS_IGNORE_CASE + | REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION + | REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION + | ROWS_PER_RESULTSET + | SAML_IDENTITY_PROVIDER + | SIMULATED_DATA_SHARING_CONSUMER + | SSO_LOGIN_PAGE + | STATEMENT_QUEUED_TIMEOUT_IN_SECONDS + | STATEMENT_TIMEOUT_IN_SECONDS + | STRICT_JSON_OUTPUT + | SUSPEND_TASK_AFTER_NUM_FAILURES + | TIMESTAMP_DAY_IS_ALWAYS_24H + | TIMESTAMP_INPUT_FORMAT + | TIMESTAMP_LTZ_OUTPUT_FORMAT + | TIMESTAMP_NTZ_OUTPUT_FORMAT + | TIMESTAMP_OUTPUT_FORMAT + | TIMESTAMP_TYPE_MAPPING + | TIMESTAMP_TZ_OUTPUT_FORMAT + | TIMEZONE + | TIME_INPUT_FORMAT + | TIME_OUTPUT_FORMAT + | TRANSACTION_ABORT_ON_ERROR + | TRANSACTION_DEFAULT_ISOLATION_LEVEL + | TWO_DIGIT_CENTURY_START + | UNSUPPORTED_DDL_ACTION + | USE_CACHED_RESULT + | USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE + | USER_TASK_TIMEOUT_MS + | WEEK_OF_YEAR_POLICY + | WEEK_START + ; + +session_parameter_list + : session_parameter (COMMA session_parameter)* + ; + +session_parameter_init_list + : session_parameter_init (COMMA session_parameter_init)* + ; + +session_parameter_init + : session_parameter EQ true_false + ; + +create_task + : CREATE or_replace? TASK if_not_exists? object_name + ( (WAREHOUSE EQ string) | (USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE EQ string ) )? + ( SCHEDULE EQ string )? + ( ALLOW_OVERLAPPING_EXECUTION EQ true_false )? + session_parameter_init_list? + ( USER_TASK_TIMEOUT_MS EQ num )? + ( SUSPEND_TASK_AFTER_NUM_FAILURES EQ num )? + ( ERROR_INTEGRATION EQ id_ )? + copy_grants? + comment_clause? + ( AFTER string (COMMA string)* )? + ( WHEN search_condition )? + AS + sql + ; + +sql + : sql_command + | call + | DBL_DOLLAR + ; + +call + : CALL object_name '(' expr_list? ')' + ; + +create_user + : CREATE or_replace? USER if_not_exists? id_ object_properties? object_params? session_params? + ; + +view_col + : column_name with_masking_policy with_tags + ; + +create_view + : CREATE or_replace? SECURE? RECURSIVE? VIEW if_not_exists? object_name + ( LR_BRACKET column_list RR_BRACKET )? + view_col* + with_row_access_policy? + with_tags? + copy_grants? + comment_clause? + AS query_statement + ; + +create_warehouse + : CREATE or_replace? WAREHOUSE if_not_exists? id_ + ( WITH? wh_properties+ )? + wh_params* + ; + +wh_properties + : WAREHOUSE_SIZE EQ (XSMALL | SMALL | MEDIUM | LARGE | XLARGE | XXLARGE | XXXLARGE | X4LARGE | X5LARGE | X6LARGE) + | MAX_CLUSTER_COUNT EQ num + | MIN_CLUSTER_COUNT EQ num + | SCALING_POLICY EQ STANDARD | ECONOMY + | AUTO_SUSPEND (EQ num | NULL_) + | AUTO_RESUME EQ true_false + | INITIALLY_SUSPENDED EQ true_false + | RESOURCE_MONITOR EQ id_ + | comment_clause + | ENABLE_QUERY_ACCELERATION EQ true_false + | QUERY_ACCELERATION_MAX_SCALE_FACTOR EQ num + ; + +wh_params + : MAX_CONCURRENCY_LEVEL EQ num + | STATEMENT_QUEUED_TIMEOUT_IN_SECONDS EQ num + | STATEMENT_TIMEOUT_IN_SECONDS EQ num + with_tags? + ; + +trigger_definition + : ON num PERCENT DO ( SUSPEND | SUSPEND_IMMEDIATE | NOTIFY ) + ; + +object_type_name + : ROLE + | USER + | WAREHOUSE + | INTEGRATION + | NETWORK POLICY + | SESSION POLICY + | DATABASE + | SCHEMA + | TABLE + | VIEW + | STAGE + | FILE FORMAT + | STREAM + | TASK + | MASKING POLICY + | ROW ACCESS POLICY + | TAG + | PIPE + | FUNCTION + | PROCEDURE + | SEQUENCE + ; + +object_type_plural + : ROLES + | USERS + | WAREHOUSES + | INTEGRATIONS + | DATABASES + | SCHEMAS + | TABLES + | VIEWS + | STAGES + | STREAMS + | TASKS + ; + +// drop commands +drop_command + : drop_object + | drop_alert + | drop_connection + | drop_database + | drop_dynamic_table + | drop_external_table + | drop_failover_group + | drop_file_format + | drop_function + | drop_integration + | drop_managed_account + | drop_masking_policy + | drop_materialized_view + | drop_network_policy + | drop_pipe + | drop_procedure + | drop_replication_group + | drop_resource_monitor + | drop_role + | drop_row_access_policy + | drop_schema + | drop_sequence + | drop_session_policy + | drop_share + | drop_stage + | drop_stream + | drop_table + | drop_tag + | drop_task + | drop_user + | drop_view + | drop_warehouse + ; + +drop_object + : DROP object_type if_exists id_ cascade_restrict? + ; + +drop_alert + : DROP ALERT id_ + ; + +drop_connection + : DROP CONNECTION if_exists? id_ + ; + +drop_database + : DROP DATABASE if_exists? id_ cascade_restrict? + ; + +drop_dynamic_table + : DROP DYNAMIC TABLE if_exists? id_ + ; + +drop_external_table + : DROP EXTERNAL TABLE if_exists? object_name cascade_restrict? + ; + +drop_failover_group + : DROP FAILOVER GROUP if_exists? id_ + ; + +drop_file_format + : DROP FILE FORMAT if_exists? id_ + ; + +drop_function + : DROP FUNCTION if_exists? object_name arg_types + ; + +drop_integration + : DROP ( API | NOTIFICATION | SECURITY | STORAGE )? INTEGRATION if_exists? id_ + ; + +drop_managed_account + : DROP MANAGED ACCOUNT id_ + ; + +drop_masking_policy + : DROP MASKING POLICY id_ + ; + +drop_materialized_view + : DROP MATERIALIZED VIEW if_exists? object_name + ; + +drop_network_policy + : DROP NETWORK POLICY if_exists? id_ + ; + +drop_pipe + : DROP PIPE if_exists? object_name + ; + +drop_procedure + : DROP PROCEDURE if_exists? object_name arg_types + ; + +drop_replication_group + : DROP REPLICATION GROUP if_exists? id_ + ; + +drop_resource_monitor + : DROP RESOURCE MONITOR id_ + ; + +drop_role + : DROP ROLE if_exists? id_ + ; + +drop_row_access_policy + : DROP ROW ACCESS POLICY if_exists? id_ + ; + +drop_schema + : DROP SCHEMA if_exists? schema_name cascade_restrict? + ; + +drop_sequence + : DROP SEQUENCE if_exists? object_name cascade_restrict? + ; + +drop_session_policy + : DROP SESSION POLICY if_exists? id_ + ; + +drop_share + : DROP SHARE id_ + ; + +drop_stage + : DROP STAGE if_exists? object_name + ; + +drop_stream + : DROP STREAM if_exists? object_name + ; + +drop_table + : DROP TABLE if_exists? object_name cascade_restrict? + ; + +drop_tag + : DROP TAG if_exists? id_ + ; + +drop_task + : DROP TASK if_exists? object_name + ; + +drop_user + : DROP USER if_exists? id_ + ; + +drop_view + : DROP VIEW if_exists? object_name + ; + +drop_warehouse + : DROP WAREHOUSE if_exists? id_ + ; + +cascade_restrict + : CASCADE | RESTRICT + ; + +arg_types + : LR_BRACKET data_type_list? RR_BRACKET + ; + +// undrop commands +undrop_command + //: undrop_object + : undrop_database + | undrop_dynamic_table + | undrop_schema + | undrop_table + | undrop_tag + ; + +undrop_database + : UNDROP DATABASE id_ + ; + +undrop_dynamic_table + : UNDROP DYNAMIC TABLE id_ + ; + +undrop_schema + : UNDROP SCHEMA schema_name + ; + +undrop_table + : UNDROP TABLE object_name + ; + +undrop_tag + : UNDROP TAG id_ + ; + +// use commands +use_command + : use_database + | use_role + | use_schema + | use_secondary_roles + | use_warehouse + ; + +use_database + : USE DATABASE id_ + ; + +use_role + : USE ROLE id_ + ; + +use_schema + : USE SCHEMA? (id_ DOT)? id_ + ; + +use_secondary_roles + : USE SECONDARY ROLES ( ALL | NONE ) + ; + +use_warehouse + : USE WAREHOUSE id_ + ; + +/* */ +comment_clause + : COMMENT EQ string + ; + +if_suspended + : IF SUSPENDED + ; + +if_exists + : IF EXISTS + ; + +if_not_exists + : IF NOT EXISTS + ; + +or_replace + : OR REPLACE + ; + +describe + : DESC | DESCRIBE + ; + +// describe command +describe_command + : describe_alert + | describe_database + | describe_dynamic_table + | describe_external_table + | describe_file_format + | describe_function + | describe_integration + | describe_masking_policy + | describe_materialized_view + | describe_network_policy + | describe_pipe + | describe_procedure + | describe_result + | describe_row_access_policy + | describe_schema + | describe_search_optimization + | describe_sequence + | describe_session_policy + | describe_share + | describe_stage + | describe_stream + | describe_table + | describe_task + | describe_transaction + | describe_user + | describe_view + | describe_warehouse + ; + +describe_alert + : describe ALERT id_ + ; + +describe_database + : describe DATABASE id_ + ; + +describe_dynamic_table + : describe DYNAMIC TABLE id_ + ; + +describe_external_table + : describe EXTERNAL? TABLE object_name ( TYPE EQ (COLUMNS | STAGE) )? + ; + +describe_file_format + : describe FILE FORMAT id_ + ; + +describe_function + : describe FUNCTION object_name arg_types + ; + +describe_integration + : describe ( API | NOTIFICATION | SECURITY | STORAGE )? INTEGRATION id_ + ; + +describe_masking_policy + : describe MASKING POLICY id_ + ; + +describe_materialized_view + : describe MATERIALIZED VIEW object_name + ; + +describe_network_policy + : describe NETWORK POLICY id_ + ; + +describe_pipe + : describe PIPE object_name + ; + +describe_procedure + : describe PROCEDURE object_name arg_types + ; + +describe_result + : describe RESULT ( STRING | LAST_QUERY_ID LR_BRACKET RR_BRACKET ) + ; + +describe_row_access_policy + : describe ROW ACCESS POLICY id_ + ; + +describe_schema + : describe SCHEMA schema_name + ; + +describe_search_optimization + : describe SEARCH OPTIMIZATION ON object_name + ; + +describe_sequence + : describe SEQUENCE object_name + ; + +describe_session_policy + : describe SESSION POLICY id_ + ; + +describe_share + : describe SHARE id_ + ; + +describe_stage + : describe STAGE object_name + ; + +describe_stream + : describe STREAM object_name + ; + +describe_table + : describe TABLE object_name ( TYPE EQ (COLUMNS | STAGE ) )? + ; + +describe_task + : describe TASK object_name + ; + +describe_transaction + : describe TRANSACTION num + ; + +describe_user + : describe USER id_ + ; + +describe_view + : describe VIEW object_name + ; + +describe_warehouse + : describe WAREHOUSE id_ + ; + +// show commands +show_command + : show_alerts + | show_columns + | show_connections + | show_databases + | show_databases_in_failover_group + | show_databases_in_replication_group + | show_delegated_authorizations + | show_external_functions + | show_dynamic_tables + | show_external_tables + | show_failover_groups + | show_file_formats + | show_functions + | show_global_accounts + | show_grants + | show_integrations + | show_locks + | show_managed_accounts + | show_masking_policies + | show_materialized_views + | show_network_policies + | show_objects + | show_organization_accounts + | show_parameters + | show_pipes + | show_primary_keys + | show_procedures + | show_regions + | show_replication_accounts + | show_replication_databases + | show_replication_groups + | show_resource_monitors + | show_roles + | show_row_access_policies + | show_schemas + | show_sequences + | show_session_policies + | show_shares + | show_shares_in_failover_group + | show_shares_in_replication_group + | show_stages + | show_streams + | show_tables + | show_tags + | show_tasks + | show_transactions + | show_user_functions + | show_users + | show_variables + | show_views + | show_warehouses + ; + +show_alerts + : SHOW TERSE? ALERTS like_pattern? + ( IN ( ACCOUNT | DATABASE id_? | SCHEMA schema_name? ) )? + starts_with? + limit_rows? + ; + +show_columns + : SHOW COLUMNS like_pattern? ( IN ( ACCOUNT | DATABASE id_? | SCHEMA schema_name? | TABLE | TABLE? object_name | VIEW | VIEW? object_name ) )? + ; + +show_connections + : SHOW CONNECTIONS like_pattern? + ; + +starts_with + : STARTS WITH string + ; + +limit_rows + : LIMIT num ( FROM string )? + ; + +show_databases + : SHOW TERSE? DATABASES HISTORY? like_pattern? + starts_with? + limit_rows? + ; + +show_databases_in_failover_group + : SHOW DATABASES IN FAILOVER GROUP id_ + ; + +show_databases_in_replication_group + : SHOW DATABASES IN REPLICATION GROUP id_ + ; + +show_delegated_authorizations + : SHOW DELEGATED AUTHORIZATIONS + | SHOW DELEGATED AUTHORIZATIONS BY USER id_ + | SHOW DELEGATED AUTHORIZATIONS TO SECURITY INTEGRATION id_ + ; + +show_external_functions + : SHOW EXTERNAL FUNCTIONS like_pattern? + ; + +show_dynamic_tables + : SHOW DYNAMIC TABLES like_pattern? + ( IN ( ACCOUNT | DATABASE id_? | SCHEMA? schema_name? ) )? + starts_with? + limit_rows? + ; + +show_external_tables + : SHOW TERSE? EXTERNAL TABLES like_pattern? + ( IN ( ACCOUNT | DATABASE id_? | SCHEMA? schema_name? ) )? + starts_with? + limit_rows? + ; + +show_failover_groups + : SHOW FAILOVER GROUPS ( IN ACCOUNT id_ )? + ; + +show_file_formats + : SHOW FILE FORMATS like_pattern? + ( IN + ( + ACCOUNT | + DATABASE | + DATABASE id_ | + SCHEMA | + SCHEMA schema_name | + schema_name + ) + )? + ; + +show_functions + : SHOW FUNCTIONS like_pattern? ( IN ( ACCOUNT | DATABASE | DATABASE id_ | SCHEMA | SCHEMA id_ | id_ ) )? + ; + +show_global_accounts + : SHOW GLOBAL ACCOUNTS like_pattern? + ; + +show_grants + : SHOW GRANTS show_grants_opts? + | SHOW FUTURE GRANTS IN SCHEMA schema_name + | SHOW FUTURE GRANTS IN DATABASE id_ + ; + +show_grants_opts + : ON ACCOUNT + | ON object_type object_name + | TO (ROLE id_ | USER id_ | SHARE id_ ) + | OF ROLE id_ + | OF SHARE id_ + ; + +show_integrations + : SHOW ( API | NOTIFICATION | SECURITY | STORAGE )? INTEGRATIONS like_pattern? + ; + +show_locks + : SHOW LOCKS ( IN ACCOUNT )? + ; + +show_managed_accounts + : SHOW MANAGED ACCOUNTS like_pattern? + ; + +show_masking_policies + : SHOW MASKING POLICIES like_pattern? in_obj? + ; + +in_obj + : IN ( ACCOUNT + | DATABASE + | DATABASE id_ + | SCHEMA + | SCHEMA schema_name + | schema_name + ) + ; + +in_obj_2 + : IN ( ACCOUNT + | DATABASE id_? + | SCHEMA schema_name? + | TABLE + | TABLE object_name + ) + ; + +show_materialized_views + : SHOW MATERIALIZED VIEWS like_pattern? in_obj? + ; + +show_network_policies + : SHOW NETWORK POLICIES + ; + +show_objects + : SHOW OBJECTS like_pattern? in_obj? + ; + +show_organization_accounts + : SHOW ORGANIZATION ACCOUNTS like_pattern? + ; + +in_for + : IN | FOR + ; + +show_parameters + : SHOW PARAMETERS like_pattern? + ( in_for ( SESSION | ACCOUNT | USER id_? | ( WAREHOUSE | DATABASE | SCHEMA | TASK ) id_? | TABLE object_name ) )? + ; + +show_pipes + : SHOW PIPES like_pattern? in_obj? + ; + +show_primary_keys + : SHOW TERSE? PRIMARY KEYS in_obj_2? + ; + +show_procedures + : SHOW PROCEDURES like_pattern? in_obj? + ; + +show_regions + : SHOW REGIONS like_pattern? + ; + +show_replication_accounts + : SHOW REPLICATION ACCOUNTS like_pattern? + ; + +show_replication_databases + : SHOW REPLICATION DATABASES like_pattern? ( WITH PRIMARY account_identifier DOT id_ )? + ; + +show_replication_groups + : SHOW REPLICATION GROUPS (IN ACCOUNT id_ )? + ; + +show_resource_monitors + : SHOW RESOURCE MONITORS like_pattern? + ; + +show_roles + : SHOW ROLES like_pattern? + ; + +show_row_access_policies + : SHOW ROW ACCESS POLICIES like_pattern? in_obj? + ; + +show_schemas + : SHOW TERSE? SCHEMAS HISTORY? like_pattern? + ( IN ( ACCOUNT | DATABASE id_? ) )? + starts_with? + limit_rows? + ; + +show_sequences + : SHOW SEQUENCES like_pattern? in_obj? + ; + +show_session_policies + : SHOW SESSION POLICIES + ; + +show_shares + : SHOW SHARES like_pattern? + ; + +show_shares_in_failover_group + : SHOW SHARES IN FAILOVER GROUP id_ + ; + +show_shares_in_replication_group + : SHOW SHARES IN REPLICATION GROUP id_ + ; + +show_stages + : SHOW STAGES like_pattern? in_obj? + ; + +show_streams + : SHOW STREAMS like_pattern? in_obj? + ; + +show_tables + : SHOW TABLES like_pattern? in_obj? + ; + +show_tags + : SHOW TAGS like_pattern? ( IN ACCOUNT | DATABASE | DATABASE id_ | SCHEMA | SCHEMA schema_name | schema_name )? + ; + +show_tasks + : SHOW TERSE? TASKS like_pattern? ( IN ( ACCOUNT | DATABASE id_? | SCHEMA? schema_name? ) )? + starts_with? + limit_rows? + ; + +show_transactions + : SHOW TRANSACTIONS ( IN ACCOUNT )? + ; + +show_user_functions + : SHOW USER FUNCTIONS like_pattern? in_obj? + ; + +show_users + : SHOW TERSE? USERS like_pattern? + ( STARTS WITH string )? + ( LIMIT num )? + ( FROM string )? + ; + +show_variables + : SHOW VARIABLES like_pattern? + ; + +show_views + : SHOW TERSE? VIEWS like_pattern? + ( IN ( ACCOUNT | DATABASE id_? | SCHEMA? schema_name? ) )? + starts_with? + limit_rows? + ; + +show_warehouses + : SHOW WAREHOUSES like_pattern? + ; + +like_pattern + : LIKE string + ; + +//names +account_identifier + : id_ + ; + +schema_name + : id_ DOT id_ + | id_ + ; + +object_type + : ACCOUNT PARAMETERS + | DATABASES + | INTEGRATIONS + | NETWORK POLICIES + | RESOURCE MONITORS + | ROLES + | SHARES + | USERS + | WAREHOUSES + ; + +object_type_list + : object_type (COMMA object_type)* + ; + +tag_value + : string + ; + +arg_data_type + : id_ + ; + +arg_name + : id_ + ; + +param_name + : id_ + ; + +region_group_id + : id_ + ; + +snowflake_region_id + : id_ + ; + +string + : STRING + ; + +string_list + : string (COMMA string)* + ; + +id_ + : ID + | ID2 + | DOUBLE_QUOTE_ID + | DOUBLE_QUOTE_BLANK + | keyword + | non_reserved_words + | data_type + | builtin_function + | ALERT + | ALERTS + | CONDITION + | supplement_non_reserved_words + ; + +keyword + : INT + | BIGINT + | STAGE + | USER + | TYPE + | CLUSTER + | TEMP + | FUNCTION + | REGION + | ROLLUP + | AT_KEYWORD + | TIMESTAMP + | IF + | COPY_OPTIONS_ + // etc + ; + +non_reserved_words + : ORGADMIN + | ACCOUNTADMIN + | SECURITYADMIN + | USERADMIN + | SYSADMIN + | PUBLIC + | JAVASCRIPT + | RESULT + | INDEX + | SOURCE + | PROCEDURE_NAME + | STATE + | ROLE + | DEFINITION + | TIMEZONE + | LOCAL + | ROW_NUMBER + | VALUE + | NAME + | TAG + | WAREHOUSE + | VERSION + | OPTION + ; + +builtin_function + // If there is a lexer entry for a function we also need to add the token here + // as it otherwise will not be picked up by the id_ rule + : IFF + | SUM + | AVG + | MIN + | COUNT + | CURRENT_TIMESTAMP + | CURRENT_DATE + | UPPER + | LOWER + | TO_BOOLEAN + ; + +list_operator + // lexer entry which admit a list of comma separated expr + : CONCAT + | CONCAT_WS + | COALESCE + // To complete as needed + ; + +binary_builtin_function + : ifnull=( IFNULL | NVL ) + | GET + | LEFT + | RIGHT + | DATE_PART + | to_date=( TO_DATE | DATE ) + | SPLIT + ; + +binary_or_ternary_builtin_function + : CHARINDEX + | REPLACE + | substring=( SUBSTRING | SUBSTR ) + | LIKE | ILIKE + ; + +ternary_builtin_function + : dateadd=( DATEADD | TIMEADD | TIMESTAMPADD ) + | datefiff=( DATEDIFF | TIMEDIFF | TIMESTAMPDIFF ) + | SPLIT_PART + ; + +pattern + : PATTERN EQ string + ; + +//pattern_assoc +// : PATTERN ASSOC string +// ; + +column_name + : id_ + ; + +column_list + : column_name (COMMA column_name)* + ; + +object_name + : d=id_ DOT s=id_ DOT o=id_ + | s=id_ DOT o=id_ + | o=id_ + ; + +num + : DECIMAL + ; + +/*** expressions ***/ +expr_list + : expr (COMMA expr)* + ; + +expr_list_sorted + : expr asc_desc? (COMMA expr asc_desc?)* + ; + +expr + : primitive_expression + | function_call + | expr COLLATE string + | case_expression + | iff_expr + | full_column_name + | bracket_expression + | op=( PLUS | MINUS ) expr + | op=NOT expr + | expr op=(STAR | DIVIDE | MODULE) expr + | expr op=(PLUS | MINUS | PIPE_PIPE) expr + | expr op=( AND | OR | NOT ) expr //bool operation + | expr LSB expr RSB //array access + | arr_literal +// | expr time_zone + | expr COLON expr //json access + | expr DOT VALUE + | expr COLON_COLON data_type //cast + | expr over_clause + | CAST LR_BRACKET expr AS data_type RR_BRACKET + | json_literal + | binary_builtin_function LR_BRACKET expr COMMA expr RR_BRACKET + | binary_or_ternary_builtin_function LR_BRACKET expr COMMA expr (COMMA expr)* RR_BRACKET + | ternary_builtin_function LR_BRACKET expr COMMA expr COMMA expr RR_BRACKET + | subquery + | try_cast_expr + | object_name DOT NEXTVAL + | trim_expression + | expr comparison_operator expr + | expr IS null_not_null + | expr NOT? IN LR_BRACKET (subquery | expr_list) RR_BRACKET + | expr NOT? ( LIKE | ILIKE ) expr (ESCAPE expr)? + | expr NOT? RLIKE expr + | expr NOT? ( LIKE | ILIKE ) ANY LR_BRACKET expr (COMMA expr)* RR_BRACKET (ESCAPE expr)? + ; + +iff_expr + : IFF '(' search_condition ',' expr ',' expr ')' + ; + +trim_expression + : ( TRIM | LTRIM | RTRIM ) LR_BRACKET expr (COMMA string)* RR_BRACKET + ; + +try_cast_expr + : TRY_CAST LR_BRACKET expr AS data_type RR_BRACKET + ; + +json_literal + : LCB kv_pair (COMMA kv_pair)* RCB + | LCB RCB + ; + +kv_pair + : key=STRING COLON value + ; + +value + : expr + ; + +arr_literal + : LSB value (',' value)* RSB + | LSB RSB + ; + +data_type + : INT + | INTEGER + | SMALLINT + | TINYINT + | BYTEINT + | BIGINT + | (NUMBER | NUMERIC | DECIMAL_) ('(' num (COMMA num)? ')')? + | FLOAT_ + | FLOAT4 + | FLOAT8 + | DOUBLE PRECISION? + | REAL_ + | BOOLEAN + | DATE + | DATETIME ('(' num ')')? + | TIME ('(' num ')')? + | TIMESTAMP ('(' num ')')? + | TIMESTAMP_LTZ ('(' num ')')? + | TIMESTAMP_NTZ ('(' num ')')? + | TIMESTAMP_TZ ('(' num ')')? + | STRING_ + | CHAR | CHARACTER + | VARCHAR ('(' num ')')? + | TEXT + | BINARY + | VARBINARY + | VARIANT + | OBJECT + | ARRAY + | GEOGRAPHY + | GEOMETRY + ; + +primitive_expression + : DEFAULT //? + | NULL_ + | id_ + | literal + //| json_literal + //| arr_literal + ; + +order_by_expr + : ORDER BY expr_list_sorted + ; + +//order_by_expr_list +// : ORDER BY expr_list +// ; + +//over_clause_window +// : OVER '(' partition_by? order_by_expr (cumulative_frame | sliding_frame)? ')' +// ; + +asc_desc + : ASC | DESC + ; + +over_clause + : OVER '(' partition_by order_by_expr? ')' + | OVER '(' order_by_expr ')' + ; + +function_call + : ranking_windowed_function + | aggregate_function +// | aggregate_windowed_function + | object_name '(' expr_list? ')' + | list_operator LR_BRACKET expr_list RR_BRACKET + | to_date=( TO_DATE | DATE ) LR_BRACKET expr RR_BRACKET + | length= ( LENGTH | LEN ) LR_BRACKET expr RR_BRACKET + | TO_BOOLEAN LR_BRACKET expr RR_BRACKET + ; + +ranking_windowed_function + : (RANK | DENSE_RANK | ROW_NUMBER) '(' ')' over_clause + | NTILE '(' expr ')' over_clause + ; + +aggregate_function + : id_ '(' DISTINCT? expr_list ')' + | id_ '(' STAR ')' + | LISTAGG '(' DISTINCT? expr (COMMA string)? ')' (WITHIN GROUP '(' order_by_clause ')' )? + ; + +//rows_range +// : ROWS | RANGE +// ; + +//cumulative_frame +// : rows_range BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW +// | rows_range BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING +// ; + +//preceding_following +// : PRECEDING | FOLLOWING +// ; + +//sliding_frame +// : ROWS BETWEEN num preceding_following AND num preceding_following +// | ROWS BETWEEN UNBOUNDED PRECEDING AND num preceding_following +// | ROWS BETWEEN num preceding_following AND UNBOUNDED FOLLOWING +// ; + +literal + : STRING // string, date, time, timestamp + | sign? DECIMAL + | sign? (REAL | FLOAT) + | true_false + | NULL_ + | AT_Q + ; + +sign + : PLUS + | MINUS + ; + +full_column_name + : db_name=id_? DOT schema=id_? DOT tab_name=id_? DOT col_name=id_ + | schema=id_? DOT tab_name=id_? DOT col_name=id_ + | tab_name=id_? DOT col_name=id_ + | col_name=id_ + ; + +bracket_expression + : LR_BRACKET expr RR_BRACKET + | LR_BRACKET subquery RR_BRACKET + ; + +case_expression + : CASE expr switch_section+ (ELSE expr)? END + | CASE switch_search_condition_section+ (ELSE expr)? END + ; + +switch_search_condition_section + : WHEN search_condition THEN expr + ; + +switch_section + : WHEN expr THEN expr + ; + +// select +query_statement + : with_expression? + select_statement set_operators* + ; + +with_expression + : WITH common_table_expression (COMMA common_table_expression)* + ; + +common_table_expression + : RECURSIVE? id_ ('(' columns=column_list ')')? AS '(' anchor_clause UNION ALL recursive_clause ')' + // | id_ ('(' columns=column_list ')')? AS '(' select_statement set_operators* ')' + | id_ ('(' columns=column_list ')')? AS '(' query_statement ')' + ; + +anchor_clause + : query_statement + ; + +recursive_clause + // TODO(zp): from the snowflake document, https://docs.snowflake.com/en/user-guide/queries-cte#recursive-ctes-and-hierarchical-data + // the recursive_clause should not contains aggregate/windows function, LIMIT, ... + // but actually, we can use LIMIT(and others?), let's implement a superset for now... + : query_statement + ; + +select_statement + : select_clause select_optional_clauses limit_clause? + | select_top_clause select_optional_clauses //TOP and LIMIT are not allowed together + ; + +set_operators + : (UNION ALL? | (EXCEPT | MINUS_) | INTERSECT) select_statement + | ('(' select_statement ')') + ; + +select_optional_clauses + : into_clause? + from_clause? + where_clause? + group_by_clause? + qualify_clause? + order_by_clause? + ; + +select_clause + : SELECT select_list_no_top + ; + +select_top_clause + : SELECT select_list_top + ; + +select_list_no_top + : all_distinct? select_list + ; + +select_list_top + : all_distinct? top_clause select_list + ; + +select_list + : select_list_elem (COMMA select_list_elem)* + ; + +select_list_elem + : column_elem +// | udt_elem + | expression_elem + ; + +column_elem + : (object_name | alias DOT)? STAR + | (object_name | alias DOT)? column_name as_alias? + | (object_name | alias DOT)? DOLLAR column_position as_alias? + ; + +as_alias + : AS? alias + ; + +expression_elem + : ( expr | predicate ) as_alias? + ; + +column_position + : num + ; + +all_distinct + : ALL | DISTINCT + ; + +top_clause + : TOP num + ; + +into_clause + : INTO var_list + ; + +var_list + : var (COMMA var); + +var + : COLON id_ + ; + +from_clause + : FROM table_sources // object_ref join_clause* + ; + +table_sources + : table_source (',' table_source)* + ; + +table_source + : table_source_item_joined + //| '(' table_source ')' + ; + +table_source_item_joined + : object_ref join_clause* + | '(' table_source_item_joined ')' join_clause* + ; + +object_ref + : object_name + at_before? + changes? + match_recognize? + pivot_unpivot? + as_alias? + sample? + | object_name + START WITH predicate + CONNECT BY prior_list? + | TABLE '(' object_name '(' expr_list ')' ')' + pivot_unpivot? + as_alias? + sample? + | '(' values ')' + sample? + | LATERAL? '(' subquery ')' + pivot_unpivot? + as_alias? + | LATERAL flatten_table + as_alias? + //| AT id_ PATH? + // ('(' FILE_FORMAT ASSOC id_ COMMA pattern_assoc ')')? + // as_alias? + ; + +flatten_table_option + : PATH_ ASSOC string + | OUTER ASSOC true_false + | RECURSIVE ASSOC true_false + | MODE ASSOC (ARRAY_Q | OBJECT_Q | BOTH_Q) + ; + +flatten_table + : FLATTEN LR_BRACKET ( INPUT ASSOC )? expr ( COMMA flatten_table_option )* RR_BRACKET + ; + +prior_list + : prior_item (COMMA prior_item)* + ; + +prior_item + : PRIOR? id_ EQ PRIOR? id_ + ; + +outer_join + : (LEFT | RIGHT | FULL) OUTER? + ; + +join_type + : INNER + | outer_join + ; + +join_clause + : join_type? JOIN object_ref ( (ON search_condition)? | (USING '(' column_list ')')? ) + //| join_type? JOIN object_ref (USING '(' column_list ')')? + | NATURAL outer_join? JOIN object_ref + | CROSS JOIN object_ref + ; + +at_before + : AT_KEYWORD + LR_BRACKET ( + TIMESTAMP ASSOC expr + | OFFSET ASSOC expr + | STATEMENT ASSOC string + | STREAM ASSOC string + ) RR_BRACKET + | BEFORE LR_BRACKET STATEMENT ASSOC string RR_BRACKET + ; + +end + : END '(' + TIMESTAMP ARROW string + | OFFSET ARROW string + | STATEMENT ARROW id_ + ')' + ; + +changes + : CHANGES '(' INFORMATION ASSOC default_append_only ')' + at_before end? + ; + +default_append_only + : DEFAULT + | APPEND ONLY + ; + +partition_by + : PARTITION BY expr_list + ; + +alias + : id_ + ; + +expr_alias_list + : expr AS? alias (COMMA expr AS? alias)* + ; + +measures + : MEASURES expr_alias_list + ; + +match_opts + : SHOW EMPTY_ MATCHES | OMIT EMPTY_ MATCHES | WITH UNMATCHED ROWS + ; + +row_match + : (ONE ROW PER MATCH | ALL ROWS PER MATCH) match_opts? + ; + +first_last + : FIRST |LAST + ; + +symbol + : DUMMY + ; + +after_match + : AFTER MATCH SKIP_ (PAST LAST ROW | TO NEXT ROW | TO first_last? symbol) + ; + +symbol_list + : symbol AS expr (COMMA symbol AS expr)* + ; + +define + : DEFINE symbol_list + ; + +match_recognize + : MATCH_RECOGNIZE LR_BRACKET + partition_by? + order_by_clause? + measures? + row_match? + after_match? + pattern? + define? + RR_BRACKET + ; + +pivot_unpivot + : PIVOT LR_BRACKET id_ LR_BRACKET id_ RR_BRACKET FOR id_ IN LR_BRACKET literal (COMMA literal)* RR_BRACKET RR_BRACKET + | UNPIVOT LR_BRACKET id_ FOR column_name IN LR_BRACKET column_list RR_BRACKET RR_BRACKET + ; + +column_alias_list_in_brackets + : '(' id_ (COMMA id_)* ')' + ; + +expr_list_in_parentheses + : LR_BRACKET expr_list RR_BRACKET + ; + +values + : VALUES expr_list_in_parentheses (COMMA expr_list_in_parentheses)* as_alias? column_alias_list_in_brackets? + ; + +sample_method + : (BERNOULLI | ROW) + | (SYSTEM | BLOCK) + ; + +repeatable_seed + : (REPEATABLE | SEED) LR_BRACKET num RR_BRACKET + ; + +sample_opts + : LR_BRACKET (num | (num ROWS)) RR_BRACKET repeatable_seed? + ; + +sample + : (SAMPLE | TABLESAMPLE) sample_method? sample_opts + ; + +search_condition + : NOT* (predicate | '(' search_condition ')') + | search_condition AND search_condition + | search_condition OR search_condition + ; + +comparison_operator + : EQ | GT | LT | LE | GE | LTGT | NE + ; + +null_not_null + : NOT? NULL_ + ; + +subquery + : query_statement + ; + +predicate + : EXISTS LR_BRACKET subquery RR_BRACKET + | expr comparison_operator expr + | expr comparison_operator (ALL | SOME | ANY) '(' subquery ')' + | expr NOT? BETWEEN expr AND expr + | expr NOT? IN '(' (subquery | expr_list) ')' + | expr NOT? ( LIKE | ILIKE ) expr (ESCAPE expr)? + | expr NOT? RLIKE expr + | expr NOT? ( LIKE | ILIKE ) ANY LR_BRACKET expr (COMMA expr)* RR_BRACKET (ESCAPE expr)? + | expr IS null_not_null + | expr + ; + +where_clause + : WHERE search_condition + ; + +group_item + : id_ | num | expr + ; + +group_by_clause + : GROUP BY group_item (COMMA group_item)* having_clause? + | GROUP BY (CUBE | GROUPING SETS | ROLLUP) LR_BRACKET group_item (COMMA group_item)* RR_BRACKET + ; + +having_clause + : HAVING search_condition + ; + +qualify_clause + : QUALIFY expr + ; + +order_item + : ( id_ | num | expr ) (ASC | DESC)? ( NULLS ( FIRST | LAST ) )? + ; + +order_by_clause + : ORDER BY order_item (COMMA order_item)* + ; + +row_rows + : ROW | ROWS + ; + +first_next + : FIRST | NEXT + ; + +limit_clause + : LIMIT num (OFFSET num)? + | (OFFSET num )? row_rows? FETCH first_next? num row_rows? ONLY? + ; + +supplement_non_reserved_words + : AAD_PROVISIONER_Q + | ABORT + | ABORT_AFTER_WAIT + | ABORT_DETACHED_QUERY + | ABORT_STATEMENT + | ABSENT + | ABSOLUTE + | ACCESS + | ACCOUNTADMIN + | ACCOUNTS + | ACTION + | ACTIVE + | ADD + | ADMINISTER + | ADMIN_NAME + | ADMIN_PASSWORD + | AES + | AFTER + | AGGREGATE + | ALERT + | ALERTS + | ALLOWED + | ALLOWED_ACCOUNTS + | ALLOWED_DATABASES + | ALLOWED_INTEGRATION_TYPES + | ALLOWED_IP_LIST + | ALLOWED_SHARES + | ALLOWED_VALUES + | ALLOW_CLIENT_MFA_CACHING + | ALLOW_CONNECTIONS + | ALLOW_DUPLICATE + | ALLOW_ID_TOKEN + | ALLOW_MULTIPLE_EVENT_LOSS + | ALLOW_OVERLAPPING_EXECUTION + | ALLOW_SINGLE_EVENT_LOSS + | ALWAYS + | ANONYMOUS + | ANSI_DEFAULTS + | API + | API_ALLOWED_PREFIXES + | API_AWS_ROLE_ARN + | API_BLOCKED_PREFIXES + | API_INTEGRATION + | API_KEY + | API_PROVIDER + | APPEND + | APPEND_ONLY + | APPLICATION + | APPLY + | APP_NAME + | ASC + | ATTACH + | AT_KEYWORD + | AUTHORIZATION + | AUTHORIZATIONS + | AUTO + | AUTO_Q + | AUTOCOMMIT + | AUTOCOMMIT_API_SUPPORTED + | AUTOINCREMENT + | AUTO_COMPRESS + | AUTO_DETECT + | AUTO_INGEST + | AUTO_REFRESH + | AUTO_RESUME + | AUTO_SUSPEND + | AVG + | AVRO + | AVRO_Q + | AWS_KEY_ID + | AWS_ROLE + | AWS_SECRET_KEY + | AWS_SNS + | AWS_SNS_ROLE_ARN + | AWS_SNS_TOPIC + | AWS_SNS_TOPIC_ARN + | AWS_TOKEN + | AZURE + | AZURE_AD_APPLICATION_ID + | AZURE_EVENT_GRID + | AZURE_EVENT_GRID_TOPIC_ENDPOINT + | AZURE_Q + | AZURE_SAS_TOKEN + | AZURE_STORAGE_QUEUE_PRIMARY_URI + | AZURE_TENANT_ID + | BEFORE + | BEGIN + | BERNOULLI + | BINARY_AS_TEXT + | BINARY_CHECKSUM + | BINARY_FORMAT + | BINARY_INPUT_FORMAT + | BINARY_OUTPUT_FORMAT + | BINDING + | BLOCK + | BLOCKED_IP_LIST + | BLOCKED_ROLES_LIST + | BODY + | BOTH_Q + | BROTLI + | BUSINESS_CRITICAL + | CACHE + | CALL + | CALLED + | CALLER + | CASCADE + | CASE_INSENSITIVE + | CASE_SENSITIVE + | CATCH + | CERTIFICATE + | CHANGE + | CHANGES + | CHANGETABLE + | CHANGE_RETENTION + | CHANGE_TRACKING + | CHAR + | CHARACTER + | CHARINDEX + | CHECKSUM + | CHECKSUM_AGG + | CHECK_EXPIRATION + | CHECK_POLICY + | CLASSIFIER_FUNCTION + | CLEANUP + | CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS + | CLIENT_ENCRYPTION_KEY_SIZE + | CLIENT_MEMORY_LIMIT + | CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX + | CLIENT_METADATA_USE_SESSION_DATABASE + | CLIENT_PREFETCH_THREADS + | CLIENT_RESULT_CHUNK_SIZE + | CLIENT_RESULT_COLUMN_CASE_INSENSITIVE + | CLIENT_SESSION_KEEP_ALIVE + | CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY + | CLIENT_TIMESTAMP_TYPE_MAPPING + | CLONE + | CLOSE + | CLUSTER + | CLUSTERED + | CLUSTERING + | COALESCE + | COLLATE + | COLLECTION + | COLUMNS + | COL_LENGTH + | COL_NAME + | COMMENT + | COMMIT + | COMMITTED + | COMPRESS + | COMPRESSION + | CONCAT + | CONCAT_NULL_YIELDS_NULL + | CONCAT_WS + | CONDITION + | CONFIGURATION + | CONNECTIONS + | CONTAINMENT + | CONTAINS + | CONTENT + | CONTEXT + | CONTEXT_HEADERS + | CONTEXT_INFO + | CONTINUE + | CONTROL + | CONVERSATION + | COOKIE + | COPY + | COPY_ONLY + | COPY_OPTIONS_ + | COUNT + | COUNT_BIG + | CREDENTIALS + | CREDIT_QUOTA + | CSV + | CSV_Q + | CUBE + | CUME_DIST + | CURSOR + | CUSTOM + | DAILY + | DATA + | DATABASES + | DATA_RETENTION_TIME_IN_DAYS + | DATEADD + | DATEDIFF + | DATENAME + | DATEPART + | DATE_FORMAT + | DATE_INPUT_FORMAT + | DATE_OUTPUT_FORMAT + | DATE_PART + | DAYS + | DAYS_TO_EXPIRY + | DECLARE + | DEFAULT + | DEFAULT_DDL_COLLATION_ + | DEFAULT_NAMESPACE + | DEFAULT_ROLE + | DEFAULT_WAREHOUSE + | DEFERRABLE + | DEFERRED + | DEFINE + | DEFINITION + | DEFLATE + | DELEGATED + | DELTA + | DENSE_RANK + | DESC + | DESCRIBE + | DIRECTION + | DIRECTORY + | DISABLE + | DISABLED + | DISABLE_AUTO_CONVERT + | DISABLE_SNOWFLAKE_DATA + | DISK + | DISPLAY_NAME + | DO + | DOWNSTREAM + | DOUBLE + | DYNAMIC + | ECONOMY + | EDITION + | EMAIL + | EMPTY_ + | EMPTY_FIELD_AS_NULL + | ENABLE + | ENABLED + | ENABLE_FOR_PRIVILEGE + | ENABLE_INTERNAL_STAGES_PRIVATELINK + | ENABLE_OCTAL + | ENABLE_QUERY_ACCELERATION + | ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION + | ENCODING + | ENCRYPTION + | END + | ENDPOINT + | END_TIMESTAMP + | ENFORCED + | ENFORCE_LENGTH + | ENFORCE_SESSION_POLICY + | ENTERPRISE + | EQUALITY + | ERROR_INTEGRATION + | ERROR_ON_COLUMN_COUNT_MISMATCH + | ERROR_ON_NONDETERMINISTIC_MERGE + | ERROR_ON_NONDETERMINISTIC_UPDATE + | ESCAPE + | ESCAPE_UNENCLOSED_FIELD + | EXCEPT + | EXCHANGE + | EXECUTE + | EXECUTION + | EXIST + | EXIT + | EXPAND + | EXPIRY_DATE + | EXPLAIN + | EXPLICIT + | EXTERNAL + | EXTERNAL_OAUTH + | EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST + | EXTERNAL_OAUTH_ALLOWED_ROLES_LIST + | EXTERNAL_OAUTH_ANY_ROLE_MODE + | EXTERNAL_OAUTH_AUDIENCE_LIST + | EXTERNAL_OAUTH_BLOCKED_ROLES_LIST + | EXTERNAL_OAUTH_ISSUER + | EXTERNAL_OAUTH_JWS_KEYS_URL + | EXTERNAL_OAUTH_RSA_PUBLIC_KEY + | EXTERNAL_OAUTH_SCOPE_DELIMITER + | EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE + | EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM + | EXTERNAL_OAUTH_TYPE + | EXTERNAL_STAGE + | FAILOVER + | FAILOVER_MODE + | FAIL_OPERATION + | FETCH + | FIELD_DELIMITER + | FIELD_OPTIONALLY_ENCLOSED_BY + | FILE + | FILES + | FILE_EXTENSION + | FILE_FORMAT + | FILTER + | FIRST + | FIRST_NAME + | FLATTEN + | FORCE + | FOREIGN + | FORMAT + | FORMATS + | FORMAT_NAME + | FREQUENCY + | FUNCTION + | FUNCTIONS + | FUTURE + | GCP_PUBSUB + | GCP_PUBSUB_SUBSCRIPTION_NAME + | GCP_PUBSUB_TOPIC_NAME + | GCS + | GENERIC_Q + | GENERIC_SCIM_PROVISIONER_Q + | GEO + | GEOGRAPHY_OUTPUT_FORMAT + | GEOMETRY_OUTPUT_FORMAT + | GET + | GET_FILESTREAM_TRANSACTION_CONTEXT + | GLOBAL + | GOOGLE_AUDIENCE + | GOTO + | GRANTS + | GROUPING + | GROUPING_ID + | GROUPS + | GZIP + | HEADER + | HEADERS + | HEX + | HIERARCHYID + | HIGH + | HISTORY + | HOURS + | IDENTITY + | IF + | IFF + | IFNULL + | IGNORE + | IGNORE_CONSTRAINTS + | IGNORE_DUP_KEY + | IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX + | IGNORE_TRIGGERS + | IMMEDIATE + | IMMEDIATELY + | IMMUTABLE + | IMPLICIT + | IMPORT + | IMPORTED + | INDEX + | INFORMATION + | INIT + | INITIALLY + | INITIALLY_SUSPENDED + | INITIAL_REPLICATION_SIZE_LIMIT_IN_TB + | INPUT + | INSERT_ONLY + | INSTEAD + | INT + | INTEGRATION + | INTEGRATIONS + | ISNULL + | ISNUMERIC + | ISOLATION + | JAVASCRIPT + | JDBC_TREAT_DECIMAL_AS_INT + | JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC + | JDBC_USE_SESSION_TIMEZONE + | JSON + | JSON_Q + | JSON_INDENT + | JS_TREAT_INTEGER_AS_BIGINT + | KB + | KEEP + | KEY + | KEYS + | KEYSET + | KMS_KEY_ID + | LAG + | LANGUAGE + | LARGE + | LAST + | LAST_NAME + | LAST_QUERY_ID + | LAST_VALUE + | LEAD + | LEN + | LENGTH + | LEVEL + | LIMIT + | LINENO + | LIST + | LISTENER_IP + | LISTENER_PORT + | LISTING + | LOAD + | LOCAL + | LOCAL_SERVICE_NAME + | LOCATION + | LOCKS + | LOCK_TIMEOUT + | LOG + | LOGIN + | LOGIN_NAME + | LOOKER + | LOW + | LOWER + | LTRIM + | LZO + | MANAGE + | MANAGED + | MASK + | MASKED + | MASKING + | MASTER + | MASTER_KEY + | MATCH + | MATCHED + | MATCHES + | MATCH_BY_COLUMN_NAME + | MATCH_RECOGNIZE + | MATERIALIZED + | MAX_BATCH_ROWS + | MAX_CLUSTER_COUNT + | MAX_CONCURRENCY_LEVEL + | MAX_DATA_EXTENSION_TIME_IN_DAYS + | MAX_SIZE + | MEASURES + | MEDIUM + | MEMOIZABLE + | MERGE + | MIDDLE_NAME + | MIN + | MINS_TO_BYPASS_MFA + | MINS_TO_UNLOCK + | MINUS_ + | MINUTES + | MIN_CLUSTER_COUNT + | MIN_DATA_RETENTION_TIME_IN_DAYS + | MODE + | MODIFIED_AFTER + | MODIFY + | MONITOR + | MONITORS + | MONTHLY + | MOVE + | MULTI_STATEMENT_COUNT + | MULTI_USER + | MUST_CHANGE + | MUST_CHANGE_PASSWORD + | NAME + | NCHAR + | NESTED_TRIGGERS + | NETWORK + | NETWORK_POLICY + | NEVER + | NEWID + | NEWNAME + | NEWSEQUENTIALID + | NEW_ACCOUNT + | NEW_BROKER + | NEW_PASSWORD + | NEXT + | NEXTVAL + | NO + | NONE + | NONE_Q + | NORELY + | NOTIFICATION + | NOTIFICATIONS + | NOTIFICATION_INTEGRATION + | NOTIFICATION_PROVIDER + | NOTIFY + | NOTIFY_USERS + | NOVALIDATE + | NTILE + | NULLIF + | NULLS + | NULL_ + | NULL_IF + | NUMANODE + | NUMBER + | NUMERIC_ROUNDABORT + | NVL + | OAUTH + | OAUTH_ALLOW_NON_TLS_REDIRECT_URI + | OAUTH_CLIENT + | OAUTH_CLIENT_RSA_PUBLIC_KEY + | OAUTH_ENFORCE_PKCE + | OAUTH_ISSUE_REFRESH_TOKENS + | OAUTH_REDIRECT_URI + | OAUTH_REFRESH_TOKEN_VALIDITY + | OAUTH_USE_SECONDARY_ROLES + | OBJECT + | OBJECT_Q + | OBJECTS + | OBJECT_TYPES + | OFF + | OFFSET + | OFFSETS + | OKTA + | OKTA_PROVISIONER_Q + | OKTA_Q + | OLD + | OLD_ACCOUNT + | OLD_PASSWORD + | OMIT + | ONE + | ONLINE + | ONLY + | ON_ERROR + | ON_FAILURE + | OPEN + | OPERATE + | OPERATIONS + | OPTIMIZATION + | OPTION + | ORC + | ORC_Q + | ORGADMIN + | OUTBOUND + | OUTER + | OVER + | OVERRIDE + | OVERWRITE + | OWNER + | OWNERSHIP + | PAGE + | PARALLEL + | PARAMETERS + | PARAM_NODE + | PARQUET + | PARQUET_Q + | PARTIAL + | PARTITION + | PARTITIONS + | PARTITION_TYPE + | PASSWORD + | PAST + | PATH_ + | PATTERN + | PER + | PERCENT + | PERCENTILE_CONT + | PERCENTILE_DISC + | PERCENT_RANK + | PERIODIC_DATA_REKEYING + | PERMISSION_SET + | PERSISTED + | PERSIST_SAMPLE_PERCENT + | PING_FEDERATE + | PIPE + | PIPES + | PIPE_EXECUTION_PAUSED + | PIVOT + | PLAN + | PLATFORM + | POLICIES + | POLICY + | POOL + | PORT + | PRECEDING + | PRECISION + | PREDICATE + | PREFIX + | PRESERVE_SPACE + | PREVENT_UNLOAD_TO_INLINE_URL + | PREVENT_UNLOAD_TO_INTERNAL_STAGES + | PRE_AUTHORIZED_ROLES_LIST + | PRIMARY + | PRIMARY_ROLE + | PRIOR + | PRIORITY + | PRIORITY_LEVEL + | PRIVATE + | PRIVATE_KEY + | PRIVILEGES + | PROC + | PROCEDURE + | PROCEDURES + | PROCEDURE_NAME + | PROCESS + | PROFILE + | PROPERTY + | PROVIDER + | PROVIDER_KEY_NAME + | PUBLIC + | PURGE + | PUT + | PYTHON + | QUERIES + | QUERY + | QUERY_ACCELERATION_MAX_SCALE_FACTOR + | QUERY_TAG + | QUEUE + | QUOTED_IDENTIFIERS_IGNORE_CASE + | RANGE + | RANK + | RAW_DEFLATE + | READ + | READER + | READONLY + | READPAST + | READTEXT + | READWRITE + | READ_COMMITTED_SNAPSHOT + | READ_ONLY + | READ_ONLY_ROUTING_LIST + | READ_WRITE + | REBUILD + | RECEIVE + | RECLUSTER + | RECOMPILE + | RECONFIGURE + | RECORD_DELIMITER + | RECOVERY + | RECURSIVE + | RECURSIVE_TRIGGERS + | REFERENCES + | REFERENCE_USAGE + | REFRESH + | REFRESH_ON_CREATE + | REGION + | REGIONS + | REGION_GROUP + | RELATIVE + | RELY + | REMOTE + | REMOTE_PROC_TRANSACTIONS + | REMOTE_SERVICE_NAME + | REMOVE + | RENAME + | REPEATABLE + | REPLACE + | REPLACE_INVALID_CHARACTERS + | REPLICA + | REPLICATION + | REPLICATION_SCHEDULE + | REQUEST_TRANSLATOR + | REQUIRED + | REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION + | REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION + | RESET + | RESOURCE + | RESOURCES + | RESOURCE_MONITOR + | RESPONSE_TRANSLATOR + | RESTART + | RESTORE + | RESTRICT + | RESTRICTIONS + | RESULT + | RESUME + | RETAINDAYS + | RETURN + | RETURNS + | RETURN_ALL_ERRORS + | RETURN_ERRORS + | RETURN_FAILED_ONLY + | RETURN_N_ROWS + | RETURN_ROWS + | REVERSE + | REVERT + | REWIND + | ROLE + | ROLES + | ROLLBACK + | ROLLUP + | ROOT + | ROWCOUNT + | ROWGUID + | ROWLOCK + | ROWS_PER_RESULTSET + | ROW_NUMBER + | RSA_PUBLIC_KEY + | RTRIM + | RUN_AS_ROLE + | SAFE + | SAFETY + | SAML_IDENTITY_PROVIDER + | SAVE_OLD_URL + | SCALING_POLICY + | SCHEDULE + | SCHEDULER + | SCHEMAS + | SCHEME + | SCIM + | SCIM_CLIENT + | SCRIPT + | SEARCH + | SECONDARY + | SECONDARY_ONLY + | SECONDARY_ROLE + | SECONDS + | SECRET + | SECURE + | SECURITY + | SECURITYADMIN + | SEED + | SELF + | SEQUENCE + | SEQUENCES + | SERVER + | SERVICE + | SESSION + | SESSION_IDLE_TIMEOUT_MINS + | SESSION_POLICY + | SESSION_UI_IDLE_TIMEOUT_MINS + | SETS + | SETUSER + | SHARE + | SHARED + | SHARES + | SHARE_RESTRICTIONS + | SHOW + | SHOWPLAN + | SHOWPLAN_ALL + | SHOWPLAN_TEXT + | SHOWPLAN_XML + | SHOW_INITIAL_ROWS + | SIGNATURE + | SIMPLE + | SIMULATED_DATA_SHARING_CONSUMER + | SINGLE_USER + | SIZE + | SIZE_LIMIT + | SKIP_ + | SKIP_BLANK_LINES + | SKIP_BYTE_ORDER_MARK + | SKIP_FILE + | SKIP_FILE_N + | SKIP_HEADER + | SMALL + | SNAPPY + | SNAPPY_COMPRESSION + | SOUNDEX + | SOURCE + | SOURCE_COMPRESSION + | SPACE_KEYWORD + | SPARSE + | SPECIFICATION + | SPLIT + | SPLIT_PART + | SQL + | SSO_LOGIN_PAGE + | STAGE + | STAGES + | STAGE_COPY_OPTIONS + | STAGE_FILE_FORMAT + | STANDARD + | STANDBY + | STARTED + | STARTS + | START_DATE + | START_TIMESTAMP + | STATE + | STATEMENT + | STATEMENT_QUEUED_TIMEOUT_IN_SECONDS + | STATEMENT_TIMEOUT_IN_SECONDS + | STATIC + | STATISTICS + | STATS + | STATS_DATE + | STATS_STREAM + | STATUS + | STATUSONLY + | STDEV + | STDEVP + | STOP + | STOPLIST + | STOPPED + | STORAGE + | STORAGE_ALLOWED_LOCATIONS + | STORAGE_AWS_OBJECT_ACL + | STORAGE_AWS_ROLE_ARN + | STORAGE_BLOCKED_LOCATIONS + | STORAGE_INTEGRATION + | STORAGE_PROVIDER + | STR + | STREAM + | STREAMS + | STRICT + | STRICT_JSON_OUTPUT + | STRING_AGG + | STRING_ESCAPE + | STRIP_NULL_VALUES + | STRIP_OUTER_ARRAY + | STRIP_OUTER_ELEMENT + | SUBSTR + | SUBSTRING + | SUM + | SUPPORTED + | SUSPEND + | SUSPENDED + | SUSPEND_IMMEDIATE + | SUSPEND_TASK_AFTER_NUM_FAILURES + | SWAP + | SWITCH + | SYNC_PASSWORD + | SYSADMIN + | SYSTEM + | SYSTEM_USER + | TABLEAU_DESKTOP + | TABLEAU_SERVER + | TABLES + | TABLE_FORMAT + | TABULAR + | TAG + | TAGS + | TARGET + | TARGET_LAG + | TASK + | TASKS + | TEMP + | TEMPORARY + | TERSE + | TEXTSIZE + | TIES + | TIME + | TIMEADD + | TIMEDIFF + | TIMEOUT + | TIMER + | TIMESTAMP + | TIMESTAMP_FORMAT + | TIMESTAMP_INPUT_FORMAT + | TIMESTAMP_LTZ + | TIMESTAMP_LTZ_OUTPUT_FORMAT + | TIMESTAMP_NTZ + | TIMESTAMP_NTZ_OUTPUT_FORMAT + | TIMESTAMP_OUTPUT_FORMAT + | TIMESTAMP_TYPE_MAPPING + | TIMESTAMP_TZ + | TIMESTAMP_TZ_OUTPUT_FORMAT + | TIMESTAMPADD + | TIMESTAMPDIFF + | TIMEZONE + | TIME_FORMAT + | TIME_INPUT_FORMAT + | TIME_OUTPUT_FORMAT + | TO_BOOLEAN + | TO_DATE + | TOP + | TORN_PAGE_DETECTION + | TRACKING + | TRACK_CAUSALITY + | TRAN + | TRANSACTION + | TRANSACTIONS + | TRANSACTION_ABORT_ON_ERROR + | TRANSACTION_DEFAULT_ISOLATION_LEVEL + | TRANSACTION_ID + | TRANSFORM_NOISE_WORDS + | TRANSIENT + | TRANSLATE + | TRIGGERS + | TRIM + | TRIM_SPACE + | TRIPLE_DES + | TRUNCATE + | TRUNCATECOLUMNS + | TRUSTWORTHY + | TRY + | TSEQUAL + | TSQL + | TWO_DIGIT_CENTURY_START + | TWO_DIGIT_YEAR_CUTOFF + | TYPE + | TYPEPROPERTY + | TYPE_ID + | TYPE_NAME + | TYPE_WARNING + | UN + | UNBOUNDED + | UNCHECKED + | UNCOMMITTED + | UNDROP + | UNICODE + | UNKNOWN + | UNLIMITED + | UNLOCK + | UNMASK + | UNMATCHED + | UNPIVOT + | UNSAFE + | UNSET + | UNSUPPORTED_DDL_ACTION + | UOW + | UPDLOCK + | UPPER + | URL + | USAGE + | USE + | USED + | USER + | USERADMIN + | USERS + | USER_SPECIFIED + | USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE + | USER_TASK_TIMEOUT_MS + | USE_ANY_ROLE + | USE_CACHED_RESULT + | VALIDATE + | VALIDATION + | VALIDATION_MODE + | VALID_XML + | VALUE + | VAR + | VARIABLES + | VARP + | VARYING + | VERSION + | VIEWS + | VIEW_METADATA + | VISIBILITY + | VOLATILE + | WAIT + | WAREHOUSE + | WAREHOUSES + | WAREHOUSE_SIZE + | WEEKLY + | WEEK_OF_YEAR_POLICY + | WEEK_START + | WELL_FORMED_XML + | WITHIN + | WITHOUT + | WITHOUT_ARRAY_WRAPPER + | WORK + | WORKLOAD + | WRITE + | XLARGE + | XLOCK + | XML + | XML_Q + | XSMALL + | XXLARGE + | XXXLARGE + | YEARLY + | ZSTD + | ARRAY + | ARRAY_Q + | BIGINT + | BINARY + | BOOLEAN + | BYTEINT + | CHAR_VARYING + | DATE + | DATETIME + | DECIMAL_ + | FLOAT_ + | GEOGRAPHY + | GEOMETRY + | INTEGER + | NCHAR_VARYING + | NUMERIC + | NVARCHAR + | REAL_ + | SMALLINT + | STRING_ + | TEXT + | TINYINT + | VARBINARY + | VARCHAR + | VARIANT + | LISTAGG + | DUMMY + ; diff --git a/snowflake/build_id_contains_non_reserved_keywords.py b/snowflake/build_id_contains_non_reserved_keywords.py new file mode 100644 index 0000000..a6d33ba --- /dev/null +++ b/snowflake/build_id_contains_non_reserved_keywords.py @@ -0,0 +1,217 @@ +""" build_id_contains_non_reserved_keywords.py rebuilds the ID and ID2 token to contains the non-reserved keywords. + +It does the following steps in sequence: +1. extracts the token in SnowflakeLexer.g4 from "// Build id contains the build non reserved keywords start." + to "// Build id contains The token for "the build non reserved keywords stop" is extracted. +2. At the end of SnowflakeParser.g4, write the supplement_non_reserved_words rule, + and add supplement_non_reserved_words to the rule for id_ as a candidate. + +Usage: +python3 build_id_contains_non_reserved_keywords.py +""" + +import re + +snowflake_reserved_keyword = { + "ACCOUNT": True, + "ALL": True, + "ALTER": True, + "AND": True, + "ANY": True, + "AS": True, + + "BETWEEN": True, + "BY": True, + + "CASE": True, + "CAST": True, + "CHECK": True, + "COLUMN": True, + "CONNECT": True, + "CONNECTION": True, + "CONSTRAINT": True, + "CREATE": True, + "CROSS": True, + "CURRENT": True, + "CURRENT_DATE": True, + "CURRENT_TIME": True, + "CURRENT_TIMESTAMP": True, + "CURRENT_USER": True, + + "DATABASE": True, + "DELETE": True, + "DISTINCT": True, + "DROP": True, + + "ELSE": True, + "EXISTS": True, + "FALSE": True, + "FOLLOWING": True, + "FOR": True, + "FROM": True, + "FULL": True, + + "GRANT": True, + "GROUP": True, + "GSCLUSTER": True, + + "HAVING": True, + + "ILIKE": True, + "IN": True, + "INCREMENT": True, + "INNER": True, + "INSERT": True, + "INTERSECT": True, + "INTO": True, + "IS": True, + "ISSUE": True, + + "JOIN": True, + + "LATERAL": True, + "LEFT": True, + "LIKE": True, + "LOCALTIME": True, + "LOCALTIMESTAMP": True, + + "MINUS": True, + + "NATURAL": True, + "NOT": True, + "NULL": True, + + "OF": True, + "ON": True, + "OR": True, + "ORDER": True, + "ORGANIZATION": True, + + "QUALIFY": True, + + "REGEXP": True, + "REVOKE": True, + "RIGHT": True, + "RLIKE": True, + "ROW": True, + "ROWS": True, + + "SAMPLE": True, + "SCHEMA": True, + "SELECT": True, + "SET": True, + "SOME": True, + "START": True, + + "TABLE": True, + "TABLESAMPLE": True, + "THEN": True, + "TO": True, + "TRIGGER": True, + "TRUE": True, + "TRY_CAST": True, + + "UNION": True, + "UNIQUE": True, + "UPDATE": True, + "USING": True, + + "VALUES": True, + "VIEW": True, + + "WHEN": True, + "WHENEVER": True, + "WHERE": True, + "WITH": True +} + +def read_tokens_name_before_token_from_lexer_file(filepath: str, token: str) -> list[str]: + tokens_name_before_token = [] + regex = r"^(?P[A-Z_]+)\s*:" + start_placeholder = "Build id contains the non reserved keywords start." + stop_placeholder = "Build id contains the non reserved keywords stop." + begin = False + with open(filepath, "r") as lexer_file: + lines = lexer_file.readlines() + for line in lines: + if start_placeholder in line: + begin = True + continue + if line.isspace() or (not begin): + continue + if (stop_placeholder in line): + break + + matches = re.finditer(regex, line, re.MULTILINE) + for matchNum, match in enumerate(matches, start=1): + if matchNum > 1: + break + if match.group("token_name") == token: + break + tokens_name_before_token.append(match.group("token_name")) + return tokens_name_before_token + +def pretty_print(tokens: list[str], hello: str | None) -> None: + if hello is not None: + print(hello) + # Format: + # item: [N]: token_name + # 5 items in one line, N is the index of the token in the list. + for index, element in enumerate(tokens): + print(f"[{index}]: {element}", end=", " if (index+1) % 5 != 0 and index != len(tokens) - 1 else "\n") + + print() + +def append_non_reserved_token_to_rules_in_parser(parser_file_path: str, append_rules_token_name: str, new_token_name: str, token_list: list[str]): + content = "" + with open(parser_file_path, "r+") as file: + content = file.read() + token_content = get_content_by_token_name(content, append_rules_token_name) + if token_content is None: + print(f"Cannot find token {append_rules_token_name} in {parser_file_path}") + return + # Remove the last semicolon. + new_token_content = token_content[:-1] + # Append new token name. + new_token_content += f"| {new_token_name}\n ;" + if new_token_name not in token_content: + content = content.replace(token_content, new_token_content) + + # Append new token rule. + new_token_rule = "" + for index, identifier in enumerate(token_list): + if index == 0: + new_token_rule += f"{new_token_name}\n : {identifier}" + else: + new_token_rule += f"\n | {identifier}" + new_token_rule += f"\n ;" + already_exist_new_token_rule = get_content_by_token_name(content, new_token_name) + if already_exist_new_token_rule: + content = content.replace(already_exist_new_token_rule, new_token_rule) + else: + content = content + "\n" + new_token_rule + "\n" + with open(parser_file_path, "w") as file: + file.write(content) + file.flush() + + + +def get_content_by_token_name(content: str, token_name: str) -> str: + token_regex = r"^(%s)\s*:[.\s\S]*?;" % token_name + # Get the content of the rules_regex match. + token_content = re.search(token_regex, content, re.MULTILINE) + if token_content: + return token_content.group(0) + return None + + + + +if __name__ == "__main__": + tokens = read_tokens_name_before_token_from_lexer_file("SnowflakeLexer.g4", "ID") + pretty_print(tokens, "Tokens before ID token:") + filtered_tokens = [item for item in tokens if item not in snowflake_reserved_keyword] + pretty_print(filtered_tokens, "Tokens before ID token without reserved keywords:") + append_non_reserved_token_to_rules_in_parser("SnowflakeParser.g4", "id_", "supplement_non_reserved_words", filtered_tokens) + + diff --git a/snowflake/examples/alerts.sql b/snowflake/examples/alerts.sql new file mode 100644 index 0000000..8db350e --- /dev/null +++ b/snowflake/examples/alerts.sql @@ -0,0 +1,23 @@ +CREATE OR REPLACE ALERT myalert + WAREHOUSE = mywarehouse + SCHEDULE = '1 minute' + IF( EXISTS( + SELECT gauge_value FROM gauge WHERE gauge_value>200)) + THEN +INSERT INTO gauge_value_exceeded_history VALUES (current_timestamp()); + +ALTER ALERT myalert RESUME; + +ALTER ALERT my_alert SET WAREHOUSE = my_other_warehouse; + +ALTER ALERT my_alert SET SCHEDULE = '2 minutes'; + +ALTER ALERT my_alert MODIFY CONDITION EXISTS (SELECT gauge_value FROM gauge WHERE gauge_value>300); + +ALTER ALERT my_alert MODIFY ACTION CALL my_procedure(); + +DROP ALERT myalert; + +SHOW ALERTS; + +DESC ALERT myalert; diff --git a/snowflake/examples/alter.sql b/snowflake/examples/alter.sql new file mode 100644 index 0000000..8675ff4 --- /dev/null +++ b/snowflake/examples/alter.sql @@ -0,0 +1,39 @@ +alter account a drop old url; +alter api integration ai set enabled = false; +alter connection c primary; +alter database d RENAME TO d2; +alter external table et refresh; +alter failover group fg rename to fg2; +alter file format ff RENAME TO ff2; +alter function f() RENAME TO f2; +alter masking policy mp rename to mp2; +alter materialized view mv rename to mv2; +alter network policy np rename to np2; +alter notification integration ni set enabled = false notification_provider = gcp_pubsub gcp_pubsub_subscription_name = ''; +alter pipe p REFRESH ; +alter procedure pr() RENAME TO p2; +alter replication group rg rename to rg2; +alter resource monitor rm set credit_quota = 1; +alter role r RENAME TO r2; +alter row access policy rap rename to rap2; +alter schema sch rename to sch2; +alter security integration si set enabled = true; +-- alter security integration snowflake oauth ; +-- alter security integration saml2 ; +-- alter security integration scim ; +alter sequence seq rename to seq2; +alter session set autocommit = true; +alter session policy sp rename to sp2; +alter share sh unset comment; +alter stage stg rename to stg2; +alter storage integration si set enabled = true; +alter stream st unset comment ; +alter table t rename to t2; +alter table t drop c; +alter tag tg rename to tg2; +alter task ts suspend ; +alter user u reset password ; +alter view vw set secure ; +alter warehouse wh suspend ; +alter table t add column a varchar not null; +alter table t add column a varchar not null not null constraint haha unique; diff --git a/snowflake/examples/at_before.sql b/snowflake/examples/at_before.sql new file mode 100644 index 0000000..38543ec --- /dev/null +++ b/snowflake/examples/at_before.sql @@ -0,0 +1,12 @@ +-- Time travel https://docs.snowflake.com/en/sql-reference/constructs/at-before.html +-- Examples from doc +create table my_table (id int, flag varchar(50)); -- Create table to silence linter +select * from my_table at(timestamp => 'Fri, 01 May 2015 16:20:00 -0700'::timestamp); +select * from my_table at(timestamp => to_timestamp(1432669154242, 3)); +select * from my_table at(offset => -60*5) as t where t.flag = 'valid'; +select * from my_table before(statement => '8e5d0ca9-005e-44e6-b858-a8f5b37c5726'); +select oldt.* ,newt.* + from my_table before(statement => '8e5d0ca9-005e-44e6-b858-a8f5b37c5726') as oldt + full outer join my_table at(statement => '8e5d0ca9-005e-44e6-b858-a8f5b37c5726') as newt + on oldt.id = newt.id +where oldt.id is null or newt.id is null; diff --git a/snowflake/examples/call.sql b/snowflake/examples/call.sql new file mode 100644 index 0000000..a09558d --- /dev/null +++ b/snowflake/examples/call.sql @@ -0,0 +1,2 @@ +call my_stored_proc(arg_1); +call public.some_store_procedure('some input'); diff --git a/snowflake/examples/comment.sql b/snowflake/examples/comment.sql new file mode 100644 index 0000000..2ac8621 --- /dev/null +++ b/snowflake/examples/comment.sql @@ -0,0 +1,24 @@ +comment on database d is 'd'; +comment on file format f is 'f'; +comment on function f is 'f'; +comment on integration i is 'i'; +comment on masking policy m is 'm'; +comment on network policy n is 'n'; +comment on pipe p is 'p'; +comment on procedure p is 'p'; +comment on role r is 'r'; +comment on row access policy r is 'r'; +comment on schema s is 's'; +comment on sequence s is 's'; +comment on session policy s is 's'; +comment on stage s is 's'; +comment on stream s is 's'; +comment on table t is 't'; +comment on tag t is 't'; +comment on task t is 't'; +comment on user u is 'u'; +comment on view v is 'v'; +comment on warehouse w is 'w'; +comment on column t.c IS 't.c'; +comment on column s.t.c IS 's.t.c'; +comment on column d.s.t.c IS 'd.s.t.c'; diff --git a/snowflake/examples/create.sql b/snowflake/examples/create.sql new file mode 100644 index 0000000..06b386f --- /dev/null +++ b/snowflake/examples/create.sql @@ -0,0 +1,45 @@ +create account a1 admin_name = adm admin_password = 'd' email = 'd' edition = standard; +create api integration i1 api_provider = p1 api_aws_role_arn = 'a' API_ALLOWED_PREFIXES = ('') enabled = true; +create database d1 clone d2; +create connection c1; +create database d1; +create external function e() returns int api_integration = i1 as 'dsd'; +create external table e1 (c int as 1) location = @stg/ file_format = ( type = json ); +create failover group g1 object_types = databases allowed_accounts = o.a; +create file format ff type = json ; +create function f1() returns int as '1'; +create managed account ma admin_name = ma, admin_password = 'p', type = reader; +create masking policy mp as (c int) returns int -> 1; +create materialized view mv as select 1 as c; +create network policy np allowed_ip_list = (); +create notification integration ni enabled = true type = queue notification_provider = gcp_pubsub gcp_pubsub_subscription_name = 's'; +create pipe p1 as copy into t from @stg/; +create replication group rg object_types = databases allowed_accounts = o.a; +create resource monitor rm with credit_quota = 1; +create role r; +create row access policy rap as (i int) returns boolean -> true; +create schema s; +--create security integration (external oauth); +--create security integration (snowflake oauth); +--create security integration (saml2); +create security integration si type = scim scim_client = 'okta' run_as_role = 'OKTA_PROVISIONER'; +create sequence s1; +create session policy sp comment = ''; +create share s1; +create stage s1; +create storage integration si type = external_stage storage_provider = 'S3' storage_aws_role_arn = 'r' enabled = true storage_allowed_locations = ('loc'); +create stream s1 on table t1; +create table t(i int); +create table t(i int, constraint c unique (i)); +create tag t comment ='1'; +create task t as call sp1(); +create user u; +create warehouse w; +create database public; +create or replace stream str_test2 on table test_str at (STREAM => 'STR_TEST2'); +create schema raw; +CREATE TABLE TASK(ID INT); +CREATE TABLE TASK(ID INT, FIRST_NAME VARCHAR, LAST_NAME VARCHAR); +ALTER TABLE TASK ADD COLUMN FIRST_NAME VARCHAR; +ALTER TABLE TASK ADD COLUMN LAST_NAME VARCHAR; +ALTER TABLE TASK ADD COLUMN TASK INT; diff --git a/snowflake/examples/create_fileformat.sql b/snowflake/examples/create_fileformat.sql new file mode 100644 index 0000000..45dabe9 --- /dev/null +++ b/snowflake/examples/create_fileformat.sql @@ -0,0 +1,7 @@ +CREATE FILE FORMAT TESTEMPTY; +--Line below is OK in UI +--CREATE FILE FORMAT FMT_CSV_ANSI TYPE = 'CSV' FIELD_DELIMITER = ';' SKIP_HEADER = 1 TRIM_SPACE = TRUE FIELD_OPTIONALLY_ENCLOSED_BY = NONE NULL_IF = ('') ERROR_ON_COLUMN_COUNT_MISMATCH = FALSE ESCAPE = NONE ESCAPE_UNENCLOSED_FIELD = NONE ENCODING = WINDOWS1252; +CREATE FILE FORMAT FMT_XML TYPE = 'XML' COMPRESSION = 'AUTO' PRESERVE_SPACE = FALSE STRIP_OUTER_ELEMENT = TRUE DISABLE_SNOWFLAKE_DATA = FALSE DISABLE_AUTO_CONVERT = FALSE IGNORE_UTF8_ERRORS = FALSE; +CREATE FILE FORMAT FMT_CSV_UTF8_PIPE FIELD_DELIMITER = '|' SKIP_HEADER = 1 ESCAPE_UNENCLOSED_FIELD = 'NONE' TRIM_SPACE = TRUE NULL_IF = ('') ERROR_ON_COLUMN_COUNT_MISMATCH = FALSE ; +CREATE FILE FORMAT FMT_CSV_ANSI_BS FIELD_DELIMITER = '\b' SKIP_HEADER = 1 ESCAPE_UNENCLOSED_FIELD = 'NONE' TRIM_SPACE = TRUE NULL_IF = ('') ERROR_ON_COLUMN_COUNT_MISMATCH = FALSE ENCODING = 'WINDOWS1252' ; +CREATE FILE FORMAT FMT_CSVZIP SKIP_HEADER = 1 TRIM_SPACE = TRUE FIELD_OPTIONALLY_ENCLOSED_BY = '\"' NULL_IF = ('') COMPRESSION = BZ2 ERROR_ON_COLUMN_COUNT_MISMATCH = FALSE REPLACE_INVALID_CHARACTERS = TRUE ENCODING = 'utf8' ; diff --git a/snowflake/examples/create_function.sql b/snowflake/examples/create_function.sql new file mode 100644 index 0000000..2ce4538 --- /dev/null +++ b/snowflake/examples/create_function.sql @@ -0,0 +1,2 @@ +CREATE FUNCTION FUNC1 (p1 FLOAT, p2 FLOAT) RETURNS TABLE (c1 Date) LANGUAGE JAVASCRIPT IMMUTABLE AS $$ $$; +CREATE FUNCTION FUNC1 (p1 FLOAT) RETURNS BOOLEAN VOLATILE MEMOIZABLE AS $$ $$; diff --git a/snowflake/examples/create_procedure.sql b/snowflake/examples/create_procedure.sql new file mode 100644 index 0000000..840a7c6 --- /dev/null +++ b/snowflake/examples/create_procedure.sql @@ -0,0 +1,2 @@ +create procedure p() returns int language sql as ' '; +CREATE SECURE PROCEDURE P() returns string language javascript as $$ $$; \ No newline at end of file diff --git a/snowflake/examples/create_table.sql b/snowflake/examples/create_table.sql new file mode 100644 index 0000000..7f42c26 --- /dev/null +++ b/snowflake/examples/create_table.sql @@ -0,0 +1,52 @@ +create temporary table t(i int); +create table t1 (v varchar(16777216)); +create table t2(i int) as select(i) from t; +create table t3 as select(i) from t; + +create table t1 (v varchar(16777216) comment 'hello world'); +create table t1 (v varchar(16777216) not null comment 'hello world'); +create table t1 (v varchar(32) not null unique comment 'hello world'); +create table t1 (i integer default 1 comment 'hello world'); + +create table t1 (i integer tag (t='t')); +create table t1 (i integer tag (s.t='s.t')); +create table t1 (i integer tag (d.s.t='d.s.t')); + +-- Default, collate, not null, and inline constraints can be in any order +create table t1 (i integer not null); +create table t1 (i integer not null unique); +create table t1 (i integer unique not null); +create table t1 (i integer primary key not null); +create table t1 (i integer primary key unique not null); +create table t1 (i integer not null unique primary key); +create table t1 (i integer not null default 1); +create table t1 (i integer default 1 not null); +create table t1 (i integer not null autoincrement); +create table t1 (i integer autoincrement not null); +create table t1 (v varchar(32) not null collate 'upper'); +create table t1 (v varchar(32) collate 'upper' not null); +create table t1 (v varchar(32) unique collate 'upper' not null); +create table t1 (v varchar(32) collate 'upper' unique not null); +create table t1 (v varchar(32) collate 'upper' default 'hey'); +create table t1 (v varchar(32) unique collate 'upper' default 'hey'); +create table t1 (v varchar(32) default 'hey' unique collate 'upper'); +create table t1 (v varchar(32) default 'hey' primary key collate 'upper'); + +create or replace table t1 (i integer masking policy m); +create or replace table t1 (i integer masking policy m tag (t='t')); + +create table t (i integer default 1 not null unique masking policy m tag (t='t') comment 'hello world'); +create table t (v varchar unique not null collate 'upper' masking policy m tag (t='t') comment 'hello world'); +create table public.public.public (public int); +CREATE TABLE T ( Source string NOT NULL, Query_Id string NULL, State string NOT NULL,Procedure_Name string); +create table if not exists t1 (v varchar(16777216)); +create table t1 if not exists (v varchar(16777216)); +create table if not exists t2(i int) as select(v) from t1; +create table t2 if not exists (i int) as select(v) from t1; +CREATE OR REPLACE TABLE TESTSEED (IDENT int DEFAULT SEQID.NEXTVAL,mycol string); +CREATE OR REPLACE TABLE TESTSEED2 (ident int IDENTITY START 2); +CREATE OR REPLACE TABLE TESTSEED2 (ident int IDENTITY START WITH = 2); +CREATE OR REPLACE TABLE TESTSEED2 (ident int IDENTITY START = 2 INCREMENT BY 1); +CREATE OR REPLACE TABLE TESTSEED2 (ident int IDENTITY INCREMENT 2); +create table t1 (v datetime(9)); +CREATE TABLE T1 (TIMESTAMP DATETIME,VALUE STRING,NAME STRING); \ No newline at end of file diff --git a/snowflake/examples/create_view.sql b/snowflake/examples/create_view.sql new file mode 100644 index 0000000..e7e1f99 --- /dev/null +++ b/snowflake/examples/create_view.sql @@ -0,0 +1,3 @@ +CREATE VIEW RAW.ViewName AS Select MyField FROM RAW.TABLE1; +create view v as select 1 as c; +CREATE VIEW RAW.ViewName AS WITH src AS (Select MyField FROM RAW.TABLE1 WHERE MyField IS NOT NULL) SELECT MyField FROM SRC; \ No newline at end of file diff --git a/snowflake/examples/describe.sql b/snowflake/examples/describe.sql new file mode 100644 index 0000000..f78de5c --- /dev/null +++ b/snowflake/examples/describe.sql @@ -0,0 +1,36 @@ +describe database obj; +describe table obj; +describe table obj type = columns ; +describe external table obj; +describe external table obj type = columns; +describe file format obj; +describe function obj(); +describe function obj(int); +describe function obj(int, string); +describe integration obj; +describe masking policy obj; +describe materialized view obj; +describe network policy obj; +describe pipe obj; +describe procedure obj(); +describe procedure obj(int); +describe procedure obj(string, int); +describe result '00-00'; +describe row access policy obj; +describe schema obj; +describe search optimization on obj; +describe sequence obj; +describe session policy obj; +describe share obj; +describe stage obj; +describe stream obj; +describe table db.sch.obj; +describe table sch.obj; +describe table obj; +describe task obj; +describe transaction 1; +describe user obj; +describe view db.sch.obj; +describe view sch.obj; +describe view obj; +describe warehouse obj; diff --git a/snowflake/examples/drop.sql b/snowflake/examples/drop.sql new file mode 100644 index 0000000..8762abf --- /dev/null +++ b/snowflake/examples/drop.sql @@ -0,0 +1,33 @@ +drop connection obj; +drop database obj; +drop database obj cascade; +drop external table obj; +drop failover group obj; +drop file format obj; +drop function obj(); +drop function obj(int); +drop integration obj; +drop managed account obj; +drop masking policy obj; +drop materialized view obj; +drop network policy obj; +drop pipe obj; +drop procedure obj(); +drop procedure obj(int); +drop replication group obj; +drop resource monitor obj; +drop role obj; +drop row access policy obj; +drop schema obj; +drop schema obj restrict; +drop sequence obj; +drop session policy obj; +drop share obj; +drop stage obj; +drop stream obj; +drop table obj; +drop tag obj; +drop task obj; +drop user obj; +drop view obj; +drop warehouse obj; diff --git a/snowflake/examples/dynamic_table.sql b/snowflake/examples/dynamic_table.sql new file mode 100644 index 0000000..1a088f4 --- /dev/null +++ b/snowflake/examples/dynamic_table.sql @@ -0,0 +1,19 @@ +create dynamic table dt1 + target_lag = downstream + warehouse = wh1 + as select 1 as c; + +alter dynamic table dt1 suspend; +alter dynamic table dt1 refresh; +alter dynamic table dt1 set warehouse = wh2; +alter dynamic table dt1 resume; + +describe dynamic table dt1; + +show dynamic tables; +show dynamic tables like 'dt%'; +show dynamic tables in account; + +drop dynamic table dt1; + +undrop dynamic table dt1; \ No newline at end of file diff --git a/snowflake/examples/grant.sql b/snowflake/examples/grant.sql new file mode 100644 index 0000000..da9aa7b --- /dev/null +++ b/snowflake/examples/grant.sql @@ -0,0 +1,3 @@ +grant role sysadmin to role public; +revoke role public from role public; +revoke role SECURITYADMIN from role public; \ No newline at end of file diff --git a/snowflake/examples/having.sql b/snowflake/examples/having.sql new file mode 100644 index 0000000..2f1e9ca --- /dev/null +++ b/snowflake/examples/having.sql @@ -0,0 +1 @@ +select department_id from employees group by department_id having count(*) < 10; diff --git a/snowflake/examples/ids.sql b/snowflake/examples/ids.sql new file mode 100644 index 0000000..9c435a3 --- /dev/null +++ b/snowflake/examples/ids.sql @@ -0,0 +1,3 @@ +create table alert(i int); +create table alerts(i int); +create table condition(i int); diff --git a/snowflake/examples/iff.sql b/snowflake/examples/iff.sql new file mode 100644 index 0000000..2ebfa73 --- /dev/null +++ b/snowflake/examples/iff.sql @@ -0,0 +1 @@ +select userhash, case when (a = 1) then 1 else 0 end as v1, iff(a = 1, 1, 0) as v2 from t; diff --git a/snowflake/examples/materialized_views.sql b/snowflake/examples/materialized_views.sql new file mode 100644 index 0000000..94b50fc --- /dev/null +++ b/snowflake/examples/materialized_views.sql @@ -0,0 +1,4 @@ +alter materialized view mv1 suspend recluster; +alter materialized view mv1 suspend; +alter materialized view mv1 resume recluster; +alter materialized view mv1 resume; diff --git a/snowflake/examples/merge_statement.sql b/snowflake/examples/merge_statement.sql new file mode 100644 index 0000000..951b5b1 --- /dev/null +++ b/snowflake/examples/merge_statement.sql @@ -0,0 +1,6 @@ +MERGE INTO target_table USING ( + SELECT id, description FROM source_table +) AS filtered_source_table +ON target_table.id = filtered_source_table.id +WHEN MATCHED THEN UPDATE SET a = filtered_source_table.b; + diff --git a/snowflake/examples/other.sql b/snowflake/examples/other.sql new file mode 100644 index 0000000..3197d83 --- /dev/null +++ b/snowflake/examples/other.sql @@ -0,0 +1,23 @@ +copy into t from @stage/; +copy into @stage/ from t; +commit ; +execute immediate 'select 1'; +execute task tsk; +explain select 1 as c; +get @stage/ file://; +grant ownership on table t to role r; +grant all on account to role r; +grant usage on database d to share s; +grant role r to role r2; +list @stage/; +put file:// @stage/; +remove @stage/; +revoke usage on database d from role r1; +revoke usage on database d from share sh; +revoke role r from role t1; +rollback ; +set i=1; +truncate materialized view v; +truncate table t; +unset i; +unset (i,j,k); diff --git a/snowflake/examples/select.sql b/snowflake/examples/select.sql new file mode 100644 index 0000000..1cc2f68 --- /dev/null +++ b/snowflake/examples/select.sql @@ -0,0 +1,75 @@ +-- Table with types and functions as column names +-- Causes timeout on PHP build test? +-- select user, date, iff, current_timestamp, cluster, type, region, function from edge; +SELECT MAX(src.COL3) OVER (PARTITION BY COL1) as MAXCol3 FROM Table1 AS src; +SELECT MAX(src.COL3) OVER (PARTITION BY COL1 ORDER BY COL2 DESC, COL1 ASC) as MAXCol3 FROM Table1 AS src; +SELECT MAX(src.COL3) OVER (PARTITION BY COL1 ORDER BY COL2) as MAXCol3 FROM Table1 AS src; +SELECT MAX(src.COL3) OVER (ORDER BY COL2) as MAXCol3 FROM Table1 AS src; +SELECT MAX(src.COL3) OVER (ORDER BY COL2 DESC, COL1 ASC) as MAXCol3 FROM Table1 AS src; +SELECT concat('A',' ','bcd') as result; +SELECT concat('A',' ','bcd'); +SELECT 'teststring'; +SELECT 'teststring' AS result; +SELECT cast(concat(to_date(ColDate, 'yyyyMMdd'), ' ', substring(ColHour, 1, 2), ':', substr(ColHour, 3, 2), ':', substring(ColHour, 5, 2)) as datetime) as FinalDate; +with src as (SELECT 1 as COL1 UNION SELECT 2) SELECT COL1 FROM SRC; +SELECT IFNULL(DATEADD(DAY, -1, CAST(ColDate as date)), CAST('2999-12-31' as datetime)) , NVL(TIMEADD(DAY, -1, CAST(ColDate as date)), CAST('2999-12-31' as datetime)); +SELECT RES FROM (SELECT LEFT('COL1',1) AS RES UNION SELECT RIGHT('COL1',1)) as TableRes; +SELECT to_date(select dateadd(d,-((date_part(dw,getdate())+1)%7+1),getdate())) AS Res; +SELECT TRY_CAST("150" as INT); +SELECT LEN(COL1), LENGTH (COL2) from t; +SELECT REPLACE('abcd', 'bc'), CHARINDEX('abcd','c') F; +SELECT * FROM (SELECT 1 as col1 ,'FuturCol2' as col2 union SELECT 2,'FuturCol3') PIVOT (sum(col1) FOR col2 in ('FuturCol2','FuturCol3')); +SELECT 'Detox' ILIKE ANY ('DET%', 'SEC%','DEP%','CMP%', 'TRT%','ODO%', 'INT%') as BoolResult; +SELECT ILIKE('Detox','DET%') as BoolResult, LIKE('Detox','DET%'); +SELECT UPPER('Detox') as UPRESULT; +SELECT LOWER('DeTox') as LOWRESULT; +SELECT TRIM(' test '),LTRIM(' test '),RTRIM(' test ') as Row_number; +SELECT TRUE OR TRUE AND FALSE, TRUE OR (TRUE AND FALSE), (TRUE OR TRUE) AND FALSE; +SELECT x AS "OR", x OR False AS "FALSE", x OR True AS "TRUE", x OR NULL AS "NULL" FROM logical2; +SELECT x AS "AND", x AND False AS "FALSE", x AND True AS "TRUE", x AND NULL AS "NULL" FROM logical2; +SELECT NOT FALSE OR TRUE, (NOT FALSE) OR TRUE, NOT (FALSE OR TRUE); +SELECT C1 IS NULL, C2 IS NOT NULL, C1 = C2 FROM T1; +SELECT SPLIT(C1,';') FROM T1; +SELECT SPLIT_PART(C1,';',1) FROM T1; +SELECT C1 FROM T1 WHERE NOT C2; + +-- Test Recursive CTE +WITH RECURSIVE managers + -- Column list of the "view" + (indent, employee_ID, manager_ID, employee_title, sort_key) + AS + -- Common Table Expression + ( + -- Anchor Clause + SELECT '' AS indent, + employee_ID, manager_ID, title AS employee_title, skey(employee_ID) + FROM employees + WHERE title = 'President' + + UNION ALL + + -- Recursive Clause + SELECT indent || '--- ', + employees.employee_ID, employees.manager_ID, employees.title, + sort_key || skey(employees.employee_ID) + FROM employees JOIN managers + ON employees.manager_ID = managers.employee_ID + ) + + -- This is the "main select". + SELECT + indent || employee_title AS Title, employee_ID, + manager_ID, + sort_key + FROM managers + ORDER BY sort_key + ; + +-- Test CTE in a CTE +WITH CTE1 AS ( + WITH CTE2 AS ( + SELECT * FROM T + ) + SELECT * FROM CTE2 +) +SELECT * FROM CTE1; diff --git a/snowflake/examples/show.sql b/snowflake/examples/show.sql new file mode 100644 index 0000000..9f29640 --- /dev/null +++ b/snowflake/examples/show.sql @@ -0,0 +1,49 @@ +show columns like 'na%'; +show connections like 'na%'; +show databases like 'na%'; +show databases in failover group grp; +show databases in replication group grp; +show delegated authorizations; +show external functions like 'na%'; +show external tables like 'na%'; +show failover groups ; +show file formats like 'na%'; +show functions like 'na%'; +show global accounts like 'na%'; +show grants on account ; +show integrations like 'na%'; +show locks ; +show managed accounts like 'na%'; +show masking policies like 'na%'; +show materialized views like 'na%'; +show network policies; +show objects like 'na%'; +show organization accounts like 'na%'; +show parameters like 'na%'; +show pipes like 'na%'; +show primary keys ; +show procedures like 'na%'; +show regions like 'na%'; +show replication accounts like 'na%'; +show replication databases like 'na%'; +show replication groups; +show resource monitors like 'na%'; +show roles like 'na%'; +show row access policies like 'na%'; +show schemas like 'na%'; +show sequences like 'na%'; +show session policies; +show shares like 'na%'; +show shares in failover group grp; +show shares in replication group grp; +show stages like 'na%'; +show streams like 'na%'; +show tables like 'na%'; +show tags like 'na%'; +show tasks like 'na%'; +show transactions ; +show user functions like 'na%'; +show users like 'na%'; +show variables like 'na%'; +show views like 'na%'; +show warehouses like 'na%'; diff --git a/snowflake/examples/undrop.sql b/snowflake/examples/undrop.sql new file mode 100644 index 0000000..b0ab55f --- /dev/null +++ b/snowflake/examples/undrop.sql @@ -0,0 +1,4 @@ +undrop database obj; +undrop schema obj; +undrop table obj; +undrop tag obj; diff --git a/snowflake/examples/use.sql b/snowflake/examples/use.sql new file mode 100644 index 0000000..519531b --- /dev/null +++ b/snowflake/examples/use.sql @@ -0,0 +1,7 @@ +use database obj; +use role obj; +use schema obj; +use schema sch.obj; +use secondary roles all; +use secondary roles none; +use warehouse obj; diff --git a/snowflake/parser_test.go b/snowflake/parser_test.go new file mode 100644 index 0000000..d943ff7 --- /dev/null +++ b/snowflake/parser_test.go @@ -0,0 +1,70 @@ +package snowflake_test + +import ( + "os" + "path" + "testing" + + "github.com/antlr4-go/antlr/v4" + snowflake "github.com/bytebase/parser/snowflake" + "github.com/stretchr/testify/require" +) + +type CustomErrorListener struct { + errors int +} + +func NewCustomErrorListener() *CustomErrorListener { + return new(CustomErrorListener) +} + +func (l *CustomErrorListener) SyntaxError(recognizer antlr.Recognizer, offendingSymbol interface{}, line, column int, msg string, e antlr.RecognitionException) { + l.errors += 1 + antlr.ConsoleErrorListenerINSTANCE.SyntaxError(recognizer, offendingSymbol, line, column, msg, e) +} + +func (l *CustomErrorListener) ReportAmbiguity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, exact bool, ambigAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) +} + +func (l *CustomErrorListener) ReportAttemptingFullContext(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex int, conflictingAlts *antlr.BitSet, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) +} + +func (l *CustomErrorListener) ReportContextSensitivity(recognizer antlr.Parser, dfa *antlr.DFA, startIndex, stopIndex, prediction int, configs *antlr.ATNConfigSet) { + antlr.ConsoleErrorListenerINSTANCE.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) +} + +func TestSnowflakeSQLParser(t *testing.T) { + examples, err := os.ReadDir("examples") + require.NoError(t, err) + + for _, file := range examples { + filePath := path.Join("examples", file.Name()) + t.Run(filePath, func(t *testing.T) { + t.Parallel() + input, err := antlr.NewFileStream(filePath) + require.NoError(t, err) + + lexer := snowflake.NewSnowflakeLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := snowflake.NewSnowflakeParser(stream) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + + _ = p.Snowflake_file() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) + }) + } +} diff --git a/snowflake/snowflake_lexer.go b/snowflake/snowflake_lexer.go new file mode 100644 index 0000000..de357f1 --- /dev/null +++ b/snowflake/snowflake_lexer.go @@ -0,0 +1,8776 @@ +// Code generated from SnowflakeLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package snowflake + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type SnowflakeLexer struct { + *antlr.BaseLexer + channelNames []string + modeNames []string + // TODO: EOF string +} + +var SnowflakeLexerLexerStaticData struct { + once sync.Once + serializedATN []int32 + ChannelNames []string + ModeNames []string + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func snowflakelexerLexerInit() { + staticData := &SnowflakeLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "''AAD_PROVISIONER''", "'ABORT'", "'ABORT_AFTER_WAIT'", "'ABORT_DETACHED_QUERY'", + "'ABORT_STATEMENT'", "'ABSENT'", "'ABSOLUTE'", "'ACCESS'", "'ACCOUNT'", + "'ACCOUNTADMIN'", "'ACCOUNTS'", "'ACTION'", "'ACTIVE'", "'ADD'", "'ADMINISTER'", + "'ADMIN_NAME'", "'ADMIN_PASSWORD'", "'AES'", "'AFTER'", "'AGGREGATE'", + "'ALERT'", "'ALERTS'", "'ALL'", "'ALLOWED'", "'ALLOWED_ACCOUNTS'", "'ALLOWED_DATABASES'", + "'ALLOWED_INTEGRATION_TYPES'", "'ALLOWED_IP_LIST'", "'ALLOWED_SHARES'", + "'ALLOWED_VALUES'", "'ALLOW_CLIENT_MFA_CACHING'", "'ALLOW_CONNECTIONS'", + "'ALLOW_DUPLICATE'", "'ALLOW_ID_TOKEN'", "'ALLOW_MULTIPLE_EVENT_LOSS'", + "'ALLOW_OVERLAPPING_EXECUTION'", "'ALLOW_SINGLE_EVENT_LOSS'", "'ALTER'", + "'ALWAYS'", "'AND'", "'ANONYMOUS'", "'ANSI_DEFAULTS'", "'ANY'", "'API'", + "'API_ALLOWED_PREFIXES'", "'API_AWS_ROLE_ARN'", "'API_BLOCKED_PREFIXES'", + "'API_INTEGRATION'", "'API_KEY'", "'API_PROVIDER'", "'APPEND'", "'APPEND_ONLY'", + "'APPLICATION'", "'APPLY'", "'APP_NAME'", "'AS'", "'ASC'", "'ATTACH'", + "'AT'", "'AUTHORIZATION'", "'AUTHORIZATIONS'", "'AUTO'", "''AUTO''", + "'AUTOCOMMIT'", "'AUTOCOMMIT_API_SUPPORTED'", "'AUTOINCREMENT'", "'AUTO_COMPRESS'", + "'AUTO_DETECT'", "'AUTO_INGEST'", "'AUTO_REFRESH'", "'AUTO_RESUME'", + "'AUTO_SUSPEND'", "'AVG'", "'AVRO'", "''AVRO''", "'AWS_KEY_ID'", "'AWS_ROLE'", + "'AWS_SECRET_KEY'", "'AWS_SNS'", "'AWS_SNS_ROLE_ARN'", "'AWS_SNS_TOPIC'", + "'AWS_SNS_TOPIC_ARN'", "'AWS_TOKEN'", "'AZURE'", "'AZURE_AD_APPLICATION_ID'", + "'AZURE_EVENT_GRID'", "'AZURE_EVENT_GRID_TOPIC_ENDPOINT'", "''AZURE''", + "'AZURE_SAS_TOKEN'", "'AZURE_STORAGE_QUEUE_PRIMARY_URI'", "'AZURE_TENANT_ID'", + "'BASE64'", "'BEFORE'", "'BEGIN'", "'BERNOULLI'", "'BETWEEN'", "'BINARY_AS_TEXT'", + "'BINARY_CHECKSUM'", "'BINARY_FORMAT'", "'BINARY_INPUT_FORMAT'", "'BINARY_OUTPUT_FORMAT'", + "'BINDING'", "'BLOCK'", "'BLOCKED_IP_LIST'", "'BLOCKED_ROLES_LIST'", + "'BODY'", "''BOTH''", "'BROTLI'", "'BUSINESS_CRITICAL'", "'BY'", "'BZ2'", + "'CACHE'", "'CALL'", "'CALLED'", "'CALLER'", "'CASCADE'", "'CASE'", + "'CASE_INSENSITIVE'", "'CASE_SENSITIVE'", "'CAST'", "'CATCH'", "'CERTIFICATE'", + "'CHANGE'", "'CHANGES'", "'CHANGETABLE'", "'CHANGE_RETENTION'", "'CHANGE_TRACKING'", + "'CHAR'", "'CHARACTER'", "'CHARINDEX'", "'CHECK'", "'CHECKSUM'", "'CHECKSUM_AGG'", + "'CHECK_EXPIRATION'", "'CHECK_POLICY'", "'CLASSIFIER_FUNCTION'", "'CLEANUP'", + "'CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS'", "'CLIENT_ENCRYPTION_KEY_SIZE'", + "'CLIENT_MEMORY_LIMIT'", "'CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX'", + "'CLIENT_METADATA_USE_SESSION_DATABASE'", "'CLIENT_PREFETCH_THREADS'", + "'CLIENT_RESULT_CHUNK_SIZE'", "'CLIENT_RESULT_COLUMN_CASE_INSENSITIVE'", + "'CLIENT_SESSION_KEEP_ALIVE'", "'CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY'", + "'CLIENT_TIMESTAMP_TYPE_MAPPING'", "'CLONE'", "'CLOSE'", "'CLUSTER'", + "'CLUSTERED'", "'CLUSTERING'", "'COALESCE'", "'COLLATE'", "'COLLECTION'", + "'COLUMN'", "'COLUMNS'", "'COL_LENGTH'", "'COL_NAME'", "'COMMENT'", + "'COMMIT'", "'COMMITTED'", "'COMPRESS'", "'COMPRESSION'", "'CONCAT'", + "'CONCAT_NULL_YIELDS_NULL'", "'CONCAT_WS'", "'CONDITION'", "'CONFIGURATION'", + "'CONNECT'", "'CONNECTION'", "'CONNECTIONS'", "'CONSTRAINT'", "'CONTAINMENT'", + "'CONTAINS'", "'CONTENT'", "'CONTEXT'", "'CONTEXT_HEADERS'", "'CONTEXT_INFO'", + "'CONTINUE'", "'CONTROL'", "'CONVERSATION'", "'COOKIE'", "'COPY'", "'COPY_ONLY'", + "'COPY_OPTIONS'", "'COUNT'", "'COUNT_BIG'", "'CREATE'", "'CREDENTIALS'", + "'CREDIT_QUOTA'", "'CROSS'", "'CSV'", "''CSV''", "'CUBE'", "'CUME_DIST'", + "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_USER'", "'CURSOR'", "'CUSTOM'", "'DAILY'", "'DATA'", "'DATABASE'", + "'DATABASES'", "'DATA_RETENTION_TIME_IN_DAYS'", "'DATEADD'", "'DATEDIFF'", + "'DATENAME'", "'DATEPART'", "'DATE_FORMAT'", "'DATE_INPUT_FORMAT'", + "'DATE_OUTPUT_FORMAT'", "'DATE_PART'", "'DAYS'", "'DAYS_TO_EXPIRY'", + "'DECLARE'", "'DEFAULT'", "'DEFAULT_DDL_COLLATION'", "'DEFAULT_NAMESPACE'", + "'DEFAULT_ROLE'", "'DEFAULT_WAREHOUSE'", "'DEFERRABLE'", "'DEFERRED'", + "'DEFINE'", "'DEFINITION'", "'DEFLATE'", "'DELEGATED'", "'DELETE'", + "'DELTA'", "'DENSE_RANK'", "'DESC'", "'DESCRIBE'", "'DIRECTION'", "'DIRECTORY'", + "'DISABLE'", "'DISABLED'", "'DISABLE_AUTO_CONVERT'", "'DISABLE_SNOWFLAKE_DATA'", + "'DISK'", "'DISPLAY_NAME'", "'DISTINCT'", "'DO'", "'DOWNSTREAM'", "'DOUBLE'", + "'DROP'", "'DYNAMIC'", "'ECONOMY'", "'EDITION'", "'ELSE'", "'EMAIL'", + "'EMPTY'", "'EMPTY_FIELD_AS_NULL'", "'ENABLE'", "'ENABLED'", "'ENABLE_FOR_PRIVILEGE'", + "'ENABLE_INTERNAL_STAGES_PRIVATELINK'", "'ENABLE_OCTAL'", "'ENABLE_QUERY_ACCELERATION'", + "'ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION'", "'ENCODING'", "'ENCRYPTION'", + "'END'", "'ENDPOINT'", "'END_TIMESTAMP'", "'ENFORCED'", "'ENFORCE_LENGTH'", + "'ENFORCE_SESSION_POLICY'", "'ENTERPRISE'", "'EQUALITY'", "'ERROR_INTEGRATION'", + "'ERROR_ON_COLUMN_COUNT_MISMATCH'", "'ERROR_ON_NONDETERMINISTIC_MERGE'", + "'ERROR_ON_NONDETERMINISTIC_UPDATE'", "'ESCAPE'", "'ESCAPE_UNENCLOSED_FIELD'", + "'EXCEPT'", "'EXCHANGE'", "", "'EXECUTION'", "'EXIST'", "'EXISTS'", + "'EXIT'", "'EXPAND'", "'EXPIRY_DATE'", "'EXPLAIN'", "'EXPLICIT'", "'EXTERNAL'", + "'EXTERNAL_OAUTH'", "'EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST'", + "'EXTERNAL_OAUTH_ALLOWED_ROLES_LIST'", "'EXTERNAL_OAUTH_ANY_ROLE_MODE'", + "'EXTERNAL_OAUTH_AUDIENCE_LIST'", "'EXTERNAL_OAUTH_BLOCKED_ROLES_LIST'", + "'EXTERNAL_OAUTH_ISSUER'", "'EXTERNAL_OAUTH_JWS_KEYS_URL'", "'EXTERNAL_OAUTH_RSA_PUBLIC_KEY'", + "'EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2'", "'EXTERNAL_OAUTH_SCOPE_DELIMITER'", + "'EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE'", "'EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM'", + "'EXTERNAL_OAUTH_TYPE'", "'EXTERNAL_STAGE'", "'FAILOVER'", "'FAILOVER_MODE'", + "'FAIL_OPERATION'", "'FALSE'", "'FETCH'", "'FIELD_DELIMITER'", "'FIELD_OPTIONALLY_ENCLOSED_BY'", + "'FILE'", "'FILES'", "'FILE_EXTENSION'", "'FILE_FORMAT'", "'FILTER'", + "'FIRST'", "'FIRST_NAME'", "'FLATTEN'", "'FOR'", "'FORCE'", "'FOREIGN'", + "'FORMAT'", "'FORMATS'", "'FORMAT_NAME'", "'FREQUENCY'", "'FROM'", "'FULL'", + "'FUNCTION'", "'FUNCTIONS'", "'FUTURE'", "'GCP_PUBSUB'", "'GCP_PUBSUB_SUBSCRIPTION_NAME'", + "'GCP_PUBSUB_TOPIC_NAME'", "'GCS'", "''GENERIC''", "''GENERIC_SCIM_PROVISIONER''", + "'GEO'", "'GEOGRAPHY_OUTPUT_FORMAT'", "'GEOMETRY_OUTPUT_FORMAT'", "'GET'", + "'GET_FILESTREAM_TRANSACTION_CONTEXT'", "'GLOBAL'", "'GOOGLE_AUDIENCE'", + "'GOTO'", "'GRANT'", "'GRANTS'", "'GROUP'", "'GROUPING'", "'GROUPING_ID'", + "'GROUPS'", "'GZIP'", "'HAVING'", "'HEADER'", "'HEADERS'", "'HEX'", + "'HIERARCHYID'", "'HIGH'", "'HISTORY'", "'HOURS'", "'IDENTITY'", "'IF'", + "'IFF'", "'IFNULL'", "'IGNORE'", "'IGNORE_CONSTRAINTS'", "'IGNORE_DUP_KEY'", + "'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX'", "'IGNORE_TRIGGERS'", "'IGNORE_UTF8_ERRORS'", + "'ILIKE'", "'IMMEDIATE'", "'IMMEDIATELY'", "'IMMUTABLE'", "'IMPLICIT'", + "'IMPORT'", "'IMPORTED'", "'IN'", "'INCREMENT'", "'INDEX'", "'INFORMATION'", + "'INIT'", "'INITIALLY'", "'INITIALLY_SUSPENDED'", "'INITIAL_REPLICATION_SIZE_LIMIT_IN_TB'", + "'INNER'", "'INPUT'", "'INSERT'", "'INSERT_ONLY'", "'INSTEAD'", "'INT'", + "'INTEGRATION'", "'INTEGRATIONS'", "'INTERSECT'", "'INTO'", "'IS'", + "'ISNULL'", "'ISNUMERIC'", "'ISOLATION'", "'JAVASCRIPT'", "'JDBC_TREAT_DECIMAL_AS_INT'", + "'JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC'", "'JDBC_USE_SESSION_TIMEZONE'", + "'JOIN'", "'JSON'", "''JSON''", "'JSON_INDENT'", "'JS_TREAT_INTEGER_AS_BIGINT'", + "'KB'", "'KEEP'", "'KEY'", "'KEYS'", "'KEYSET'", "'KMS_KEY_ID'", "'LAG'", + "'LANGUAGE'", "'LARGE'", "'LAST'", "'LAST_NAME'", "'LAST_QUERY_ID'", + "'LAST_VALUE'", "'LATERAL'", "'LEAD'", "'LEFT'", "'LEN'", "'LENGTH'", + "'LEVEL'", "'LIKE'", "'LIMIT'", "'LINENO'", "'LIST'", "'LISTENER_IP'", + "'LISTENER_PORT'", "'LISTING'", "'LOAD'", "'LOCAL'", "'LOCAL_SERVICE_NAME'", + "'LOCATION'", "'LOCKS'", "'LOCK_TIMEOUT'", "'LOG'", "'LOGIN'", "'LOGIN_NAME'", + "'LOOKER'", "'LOW'", "'LOWER'", "'LTRIM'", "'LZO'", "'MANAGE'", "'MANAGED'", + "'MASK'", "'MASKED'", "'MASKING'", "'MASTER'", "'MASTER_KEY'", "'MATCH'", + "'MATCHED'", "'MATCHES'", "'MATCH_BY_COLUMN_NAME'", "'MATCH_RECOGNIZE'", + "'MATERIALIZED'", "'MAX_BATCH_ROWS'", "'MAX_CLUSTER_COUNT'", "'MAX_CONCURRENCY_LEVEL'", + "'MAX_DATA_EXTENSION_TIME_IN_DAYS'", "'MAX_SIZE'", "'MEASURES'", "'MEDIUM'", + "'MEMOIZABLE'", "'MERGE'", "'MIDDLE_NAME'", "'MIN'", "'MINS_TO_BYPASS_MFA'", + "'MINS_TO_UNLOCK'", "'MINUS'", "'MINUTES'", "'MIN_CLUSTER_COUNT'", "'MIN_DATA_RETENTION_TIME_IN_DAYS'", + "'MODE'", "'MODIFIED_AFTER'", "'MODIFY'", "'MONITOR'", "'MONITORS'", + "'MONTHLY'", "'MOVE'", "'MULTI_STATEMENT_COUNT'", "'MULTI_USER'", "'MUST_CHANGE'", + "'MUST_CHANGE_PASSWORD'", "'NAME'", "'NATURAL'", "'NCHAR'", "'NESTED_TRIGGERS'", + "'NETWORK'", "'NETWORK_POLICY'", "'NEVER'", "'NEWID'", "'NEWNAME'", + "'NEWSEQUENTIALID'", "'NEW_ACCOUNT'", "'NEW_BROKER'", "'NEW_PASSWORD'", + "'NEXT'", "'NEXTVAL'", "'NO'", "'NONE'", "''NONE''", "'NORELY'", "'NOT'", + "'NOTIFICATION'", "'NOTIFICATIONS'", "'NOTIFICATION_INTEGRATION'", "'NOTIFICATION_PROVIDER'", + "'NOTIFY'", "'NOTIFY_USERS'", "'NOVALIDATE'", "'NTILE'", "'NULLIF'", + "'NULLS'", "'NULL'", "'NULL_IF'", "'NUMANODE'", "'NUMBER'", "'NUMERIC_ROUNDABORT'", + "'NVL'", "'OAUTH'", "'OAUTH_ALLOW_NON_TLS_REDIRECT_URI'", "'OAUTH_CLIENT'", + "'OAUTH_CLIENT_RSA_PUBLIC_KEY'", "'OAUTH_CLIENT_RSA_PUBLIC_KEY_2'", + "'OAUTH_ENFORCE_PKCE'", "'OAUTH_ISSUE_REFRESH_TOKENS'", "'OAUTH_REDIRECT_URI'", + "'OAUTH_REFRESH_TOKEN_VALIDITY'", "'OAUTH_USE_SECONDARY_ROLES'", "'OBJECT'", + "''OBJECT''", "'OBJECTS'", "'OBJECT_TYPES'", "'OF'", "'OFF'", "'OFFSET'", + "'OFFSETS'", "'OKTA'", "''OKTA_PROVISIONER''", "''OKTA''", "'OLD'", + "'OLD_ACCOUNT'", "'OLD_PASSWORD'", "'OMIT'", "'ON'", "'ONE'", "'ONLINE'", + "'ONLY'", "'ON_ERROR'", "'ON_FAILURE'", "'OPEN'", "'OPERATE'", "'OPERATIONS'", + "'OPTIMIZATION'", "'OPTION'", "'OR'", "'ORC'", "''ORC''", "'ORDER'", + "'ORGADMIN'", "'ORGANIZATION'", "'OUTBOUND'", "'OUTER'", "'OVER'", "'OVERRIDE'", + "'OVERWRITE'", "'OWNER'", "'OWNERSHIP'", "'PAGE'", "'PARALLEL'", "'PARAMETERS'", + "'PARAM_NODE'", "'PARQUET'", "''PARQUET''", "'PARTIAL'", "'PARTITION'", + "'PARTITIONS'", "'PARTITION_TYPE'", "'PASSWORD'", "'PAST'", "'PATH'", + "'PATTERN'", "'PER'", "'PERCENT'", "'PERCENTILE_CONT'", "'PERCENTILE_DISC'", + "'PERCENT_RANK'", "'PERIODIC_DATA_REKEYING'", "'PERMISSION_SET'", "'PERSISTED'", + "'PERSIST_SAMPLE_PERCENT'", "'PING_FEDERATE'", "'PIPE'", "'PIPES'", + "'PIPE_EXECUTION_PAUSED'", "'PIVOT'", "'PLAN'", "'PLATFORM'", "'POLICIES'", + "'POLICY'", "'POOL'", "'PORT'", "'PRECEDING'", "'PRECISION'", "'PREDICATE'", + "'PREFIX'", "'PRESERVE_SPACE'", "'PREVENT_UNLOAD_TO_INLINE_URL'", "'PREVENT_UNLOAD_TO_INTERNAL_STAGES'", + "'PRE_AUTHORIZED_ROLES_LIST'", "'PRIMARY'", "'PRIMARY_ROLE'", "'PRIOR'", + "'PRIORITY'", "'PRIORITY_LEVEL'", "'PRIVATE'", "'PRIVATE_KEY'", "'PRIVILEGES'", + "'PROC'", "'PROCEDURE'", "'PROCEDURES'", "'PROCEDURE_NAME'", "'PROCESS'", + "'PROFILE'", "'PROPERTY'", "'PROVIDER'", "'PROVIDER_KEY_NAME'", "'PUBLIC'", + "'PURGE'", "'PUT'", "'PYTHON'", "'QUALIFY'", "'QUERIES'", "'QUERY'", + "'QUERY_ACCELERATION_MAX_SCALE_FACTOR'", "'QUERY_TAG'", "'QUEUE'", "'QUOTED_IDENTIFIERS_IGNORE_CASE'", + "'RANGE'", "'RANK'", "'RAW_DEFLATE'", "'READ'", "'READER'", "'READONLY'", + "'READPAST'", "'READTEXT'", "'READWRITE'", "'READ_COMMITTED_SNAPSHOT'", + "'READ_ONLY'", "'READ_ONLY_ROUTING_LIST'", "'READ_WRITE'", "'REBUILD'", + "'RECEIVE'", "'RECLUSTER'", "'RECOMPILE'", "'RECONFIGURE'", "'RECORD_DELIMITER'", + "'RECOVERY'", "'RECURSIVE'", "'RECURSIVE_TRIGGERS'", "'REFERENCES'", + "'REFERENCE_USAGE'", "'REFRESH'", "'REFRESH_ON_CREATE'", "'REGION'", + "'REGIONS'", "'REGION_GROUP'", "'RELATIVE'", "'RELY'", "'REMOTE'", "'REMOTE_PROC_TRANSACTIONS'", + "'REMOTE_SERVICE_NAME'", "'REMOVE'", "'RENAME'", "'REPEATABLE'", "'REPLACE'", + "'REPLACE_INVALID_CHARACTERS'", "'REPLICA'", "'REPLICATION'", "'REPLICATION_SCHEDULE'", + "'REQUEST_TRANSLATOR'", "'REQUIRED'", "'REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION'", + "'REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION'", "'RESET'", "'RESOURCE'", + "'RESOURCES'", "'RESOURCE_MONITOR'", "'RESPONSE_TRANSLATOR'", "'RESTART'", + "'RESTORE'", "'RESTRICT'", "'RESTRICTIONS'", "'RESULT'", "'RESUME'", + "'RETAINDAYS'", "'RETURN'", "'RETURNS'", "'RETURN_ALL_ERRORS'", "'RETURN_ERRORS'", + "'RETURN_FAILED_ONLY'", "", "'RETURN_ROWS'", "'REVERSE'", "'REVERT'", + "'REVOKE'", "'REWIND'", "'RIGHT'", "'RLIKE'", "'ROLE'", "'ROLES'", "'ROLLBACK'", + "'ROLLUP'", "'ROOT'", "'ROW'", "'ROWCOUNT'", "'ROWGUID'", "'ROWLOCK'", + "'ROWS'", "'ROWS_PER_RESULTSET'", "'ROW_NUMBER'", "'RSA_PUBLIC_KEY'", + "'RSA_PUBLIC_KEY_2'", "'RTRIM'", "'RUN_AS_ROLE'", "''S3''", "'SAFE'", + "'SAFETY'", "'SAML2'", "'SAML2_ENABLE_SP_INITIATED'", "'SAML2_FORCE_AUTHN'", + "'SAML2_ISSUER'", "'SAML2_POST_LOGOUT_REDIRECT_URL'", "'SAML2_PROVIDER'", + "'SAML2_REQUESTED_NAMEID_FORMAT'", "'SAML2_SIGN_REQUEST'", "'SAML2_SNOWFLAKE_ACS_URL'", + "'SAML2_SNOWFLAKE_ISSUER_URL'", "'SAML2_SNOWFLAKE_X509_CERT'", "'SAML2_SP_INITIATED_LOGIN_PAGE_LABEL'", + "'SAML2_SSO_URL'", "'SAML2_X509_CERT'", "'SAML_IDENTITY_PROVIDER'", + "'SAMPLE'", "'SAVE_OLD_URL'", "'SCALING_POLICY'", "'SCHEDULE'", "'SCHEDULER'", + "'SCHEMA'", "'SCHEMAS'", "'SCHEME'", "'SCIM'", "'SCIM_CLIENT'", "'SCRIPT'", + "'SEARCH'", "'SECONDARY'", "'SECONDARY_ONLY'", "'SECONDARY_ROLE'", "'SECONDS'", + "'SECRET'", "'SECURE'", "'SECURITY'", "'SECURITYADMIN'", "'SEED'", "'SELECT'", + "'SELF'", "'SEQUENCE'", "'SEQUENCES'", "'SERVER'", "'SERVICE'", "'SESSION'", + "'SESSION_IDLE_TIMEOUT_MINS'", "'SESSION_POLICY'", "'SESSION_UI_IDLE_TIMEOUT_MINS'", + "'SET'", "'SETS'", "'SETUSER'", "'SHARE'", "'SHARED'", "'SHARES'", "'SHARE_RESTRICTIONS'", + "'SHOW'", "'SHOWPLAN'", "'SHOWPLAN_ALL'", "'SHOWPLAN_TEXT'", "'SHOWPLAN_XML'", + "'SHOW_INITIAL_ROWS'", "'SIGNATURE'", "'SIMPLE'", "'SIMULATED_DATA_SHARING_CONSUMER'", + "'SINGLE_USER'", "'SIZE'", "'SIZE_LIMIT'", "'SKIP'", "'SKIP_BLANK_LINES'", + "'SKIP_BYTE_ORDER_MARK'", "'SKIP_FILE'", "", "'SKIP_HEADER'", "'SMALL'", + "'SNAPPY'", "'SNAPPY_COMPRESSION'", "'SOME'", "'SOUNDEX'", "'SOURCE'", + "'SOURCE_COMPRESSION'", "'SPACE'", "'SPARSE'", "'SPECIFICATION'", "'SPLIT'", + "'SPLIT_PART'", "'SQL'", "'SSO_LOGIN_PAGE'", "'STAGE'", "'STAGES'", + "'STAGE_COPY_OPTIONS'", "'STAGE_FILE_FORMAT'", "'STANDARD'", "'STANDBY'", + "'START'", "'STARTED'", "'STARTS'", "'START_DATE'", "'START_TIMESTAMP'", + "'STATE'", "'STATEMENT'", "'STATEMENT_QUEUED_TIMEOUT_IN_SECONDS'", "'STATEMENT_TIMEOUT_IN_SECONDS'", + "'STATIC'", "'STATISTICS'", "'STATS'", "'STATS_DATE'", "'STATS_STREAM'", + "'STATUS'", "'STATUSONLY'", "'STDEV'", "'STDEVP'", "'STOP'", "'STOPLIST'", + "'STOPPED'", "'STORAGE'", "'STORAGE_ALLOWED_LOCATIONS'", "'STORAGE_AWS_OBJECT_ACL'", + "'STORAGE_AWS_ROLE_ARN'", "'STORAGE_BLOCKED_LOCATIONS'", "'STORAGE_INTEGRATION'", + "'STORAGE_PROVIDER'", "'STR'", "'STREAM'", "'STREAMS'", "'STRICT'", + "'STRICT_JSON_OUTPUT'", "'STRING_AGG'", "'STRING_ESCAPE'", "'STRIP_NULL_VALUES'", + "'STRIP_OUTER_ARRAY'", "'STRIP_OUTER_ELEMENT'", "'SUBSTR'", "'SUBSTRING'", + "'SUM'", "'SUPPORTED'", "'SUSPEND'", "'SUSPENDED'", "'SUSPEND_IMMEDIATE'", + "'SUSPEND_TASK_AFTER_NUM_FAILURES'", "'SWAP'", "'SWITCH'", "'SYNC_PASSWORD'", + "'SYSADMIN'", "'SYSTEM'", "'SYSTEM_USER'", "'TABLE'", "'TABLEAU_DESKTOP'", + "'TABLEAU_SERVER'", "'TABLES'", "'TABLESAMPLE'", "'TABLE_FORMAT'", "'TABULAR'", + "'TAG'", "'TAGS'", "'TARGET'", "'TARGET_LAG'", "'TASK'", "'TASKS'", + "'TEMP'", "'TEMPORARY'", "'TERSE'", "'TEXTSIZE'", "'THEN'", "'TIES'", + "'TIME'", "'TIMEADD'", "'TIMEDIFF'", "'TIMEOUT'", "'TIMER'", "'TIMESTAMP'", + "'TIMESTAMP_DAY_IS_ALWAYS_24H'", "'TIMESTAMP_FORMAT'", "'TIMESTAMP_INPUT_FORMAT'", + "'TIMESTAMP_LTZ'", "'TIMESTAMP_LTZ_OUTPUT_FORMAT'", "'TIMESTAMP_NTZ'", + "'TIMESTAMP_NTZ_OUTPUT_FORMAT'", "'TIMESTAMP_OUTPUT_FORMAT'", "'TIMESTAMP_TYPE_MAPPING'", + "'TIMESTAMP_TZ'", "'TIMESTAMP_TZ_OUTPUT_FORMAT'", "'TIMESTAMPADD'", + "'TIMESTAMPDIFF'", "'TIMEZONE'", "'TIME_FORMAT'", "'TIME_INPUT_FORMAT'", + "'TIME_OUTPUT_FORMAT'", "'TO'", "'TO_BOOLEAN'", "'TO_DATE'", "'TOP'", + "'TORN_PAGE_DETECTION'", "'TRACKING'", "'TRACK_CAUSALITY'", "'TRAN'", + "'TRANSACTION'", "'TRANSACTIONS'", "'TRANSACTION_ABORT_ON_ERROR'", "'TRANSACTION_DEFAULT_ISOLATION_LEVEL'", + "'TRANSACTION_ID'", "'TRANSFORM_NOISE_WORDS'", "'TRANSIENT'", "'TRANSLATE'", + "'TRIGGER'", "'TRIGGERS'", "'TRIM'", "'TRIM_SPACE'", "'TRIPLE_DES'", + "'TRIPLE_DES_3KEY'", "'TRUE'", "'TRUNCATE'", "'TRUNCATECOLUMNS'", "'TRUSTWORTHY'", + "'TRY'", "'TRY_CAST'", "'TSEQUAL'", "'TSQL'", "'TWO_DIGIT_CENTURY_START'", + "'TWO_DIGIT_YEAR_CUTOFF'", "'TYPE'", "'TYPEPROPERTY'", "'TYPE_ID'", + "'TYPE_NAME'", "'TYPE_WARNING'", "'UN'", "'UNBOUNDED'", "'UNCHECKED'", + "'UNCOMMITTED'", "'UNDROP'", "'UNICODE'", "'UNION'", "'UNIQUE'", "'UNKNOWN'", + "'UNLIMITED'", "'UNLOCK'", "'UNMASK'", "'UNMATCHED'", "'UNPIVOT'", "'UNSAFE'", + "'UNSET'", "'UNSUPPORTED_DDL_ACTION'", "'UOW'", "'UPDATE'", "'UPDLOCK'", + "'UPPER'", "'URL'", "'USAGE'", "'USE'", "'USED'", "'USER'", "'USERADMIN'", + "'USERS'", "'USER_SPECIFIED'", "'USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE'", + "'USER_TASK_TIMEOUT_MS'", "'USE_ANY_ROLE'", "'USE_CACHED_RESULT'", "'USING'", + "'UTF8'", "'VALIDATE'", "'VALIDATION'", "'VALIDATION_MODE'", "'VALID_XML'", + "'VALUE'", "'VALUES'", "'VAR'", "'VARIABLES'", "'VARP'", "'VARYING'", + "'VERSION'", "'VIEW'", "'VIEWS'", "'VIEW_METADATA'", "'VISIBILITY'", + "'VOLATILE'", "'WAIT'", "'WAREHOUSE'", "'WAREHOUSES'", "'WAREHOUSE_SIZE'", + "'WEEKLY'", "'WEEK_OF_YEAR_POLICY'", "'WEEK_START'", "'WELL_FORMED_XML'", + "'WHEN'", "'WHERE'", "'WITH'", "'WITHIN'", "'WITHOUT'", "'WITHOUT_ARRAY_WRAPPER'", + "'WORK'", "'WORKLOAD'", "'WRITE'", "'X4LARGE'", "'X5LARGE'", "'X6LARGE'", + "'XLARGE'", "'XLOCK'", "'XML'", "''XML''", "'XSMALL'", "'XXLARGE'", + "'XXXLARGE'", "'YEARLY'", "'ZSTD'", "'ARRAY'", "''ARRAY''", "'BIGINT'", + "'BINARY'", "'BOOLEAN'", "'BYTEINT'", "'CHAR VARYING'", "'DATE'", "'DATETIME'", + "'DECIMAL'", "'FLOAT4'", "'FLOAT8'", "'FLOAT'", "'GEOGRAPHY'", "'GEOMETRY'", + "'INTEGER'", "'NCHAR VARYING'", "'NUMERIC'", "'NVARCHAR2'", "'NVARCHAR'", + "'REAL'", "'SMALLINT'", "'STRING'", "'TEXT'", "'TINYINT'", "'VARBINARY'", + "'VARCHAR'", "'VARIANT'", "'LISTAGG'", "'DUMMY'", "", "", "", "", "", + "'\"\"'", "'''", "", "", "''s3://''", "''gcs://''", "''azure://''", + "'file://'", "", "", "", "", "", "", "'->'", "'=>'", "'!='", "'<>'", + "'='", "'>'", "'>='", "'<'", "'<='", "'!'", "'||'", "'.'", "'_'", "'@'", + "''@''", "'$'", "'('", "')'", "'['", "']'", "'{'", "'}'", "','", "';'", + "':'", "'::'", "'*'", "'/'", "'%'", "'+'", "'-'", "'?'", + } + staticData.SymbolicNames = []string{ + "", "AAD_PROVISIONER_Q", "ABORT", "ABORT_AFTER_WAIT", "ABORT_DETACHED_QUERY", + "ABORT_STATEMENT", "ABSENT", "ABSOLUTE", "ACCESS", "ACCOUNT", "ACCOUNTADMIN", + "ACCOUNTS", "ACTION", "ACTIVE", "ADD", "ADMINISTER", "ADMIN_NAME", "ADMIN_PASSWORD", + "AES", "AFTER", "AGGREGATE", "ALERT", "ALERTS", "ALL", "ALLOWED", "ALLOWED_ACCOUNTS", + "ALLOWED_DATABASES", "ALLOWED_INTEGRATION_TYPES", "ALLOWED_IP_LIST", + "ALLOWED_SHARES", "ALLOWED_VALUES", "ALLOW_CLIENT_MFA_CACHING", "ALLOW_CONNECTIONS", + "ALLOW_DUPLICATE", "ALLOW_ID_TOKEN", "ALLOW_MULTIPLE_EVENT_LOSS", "ALLOW_OVERLAPPING_EXECUTION", + "ALLOW_SINGLE_EVENT_LOSS", "ALTER", "ALWAYS", "AND", "ANONYMOUS", "ANSI_DEFAULTS", + "ANY", "API", "API_ALLOWED_PREFIXES", "API_AWS_ROLE_ARN", "API_BLOCKED_PREFIXES", + "API_INTEGRATION", "API_KEY", "API_PROVIDER", "APPEND", "APPEND_ONLY", + "APPLICATION", "APPLY", "APP_NAME", "AS", "ASC", "ATTACH", "AT_KEYWORD", + "AUTHORIZATION", "AUTHORIZATIONS", "AUTO", "AUTO_Q", "AUTOCOMMIT", "AUTOCOMMIT_API_SUPPORTED", + "AUTOINCREMENT", "AUTO_COMPRESS", "AUTO_DETECT", "AUTO_INGEST", "AUTO_REFRESH", + "AUTO_RESUME", "AUTO_SUSPEND", "AVG", "AVRO", "AVRO_Q", "AWS_KEY_ID", + "AWS_ROLE", "AWS_SECRET_KEY", "AWS_SNS", "AWS_SNS_ROLE_ARN", "AWS_SNS_TOPIC", + "AWS_SNS_TOPIC_ARN", "AWS_TOKEN", "AZURE", "AZURE_AD_APPLICATION_ID", + "AZURE_EVENT_GRID", "AZURE_EVENT_GRID_TOPIC_ENDPOINT", "AZURE_Q", "AZURE_SAS_TOKEN", + "AZURE_STORAGE_QUEUE_PRIMARY_URI", "AZURE_TENANT_ID", "BASE64", "BEFORE", + "BEGIN", "BERNOULLI", "BETWEEN", "BINARY_AS_TEXT", "BINARY_CHECKSUM", + "BINARY_FORMAT", "BINARY_INPUT_FORMAT", "BINARY_OUTPUT_FORMAT", "BINDING", + "BLOCK", "BLOCKED_IP_LIST", "BLOCKED_ROLES_LIST", "BODY", "BOTH_Q", + "BROTLI", "BUSINESS_CRITICAL", "BY", "BZ2", "CACHE", "CALL", "CALLED", + "CALLER", "CASCADE", "CASE", "CASE_INSENSITIVE", "CASE_SENSITIVE", "CAST", + "CATCH", "CERTIFICATE", "CHANGE", "CHANGES", "CHANGETABLE", "CHANGE_RETENTION", + "CHANGE_TRACKING", "CHAR", "CHARACTER", "CHARINDEX", "CHECK", "CHECKSUM", + "CHECKSUM_AGG", "CHECK_EXPIRATION", "CHECK_POLICY", "CLASSIFIER_FUNCTION", + "CLEANUP", "CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS", "CLIENT_ENCRYPTION_KEY_SIZE", + "CLIENT_MEMORY_LIMIT", "CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX", + "CLIENT_METADATA_USE_SESSION_DATABASE", "CLIENT_PREFETCH_THREADS", "CLIENT_RESULT_CHUNK_SIZE", + "CLIENT_RESULT_COLUMN_CASE_INSENSITIVE", "CLIENT_SESSION_KEEP_ALIVE", + "CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY", "CLIENT_TIMESTAMP_TYPE_MAPPING", + "CLONE", "CLOSE", "CLUSTER", "CLUSTERED", "CLUSTERING", "COALESCE", + "COLLATE", "COLLECTION", "COLUMN", "COLUMNS", "COL_LENGTH", "COL_NAME", + "COMMENT", "COMMIT", "COMMITTED", "COMPRESS", "COMPRESSION", "CONCAT", + "CONCAT_NULL_YIELDS_NULL", "CONCAT_WS", "CONDITION", "CONFIGURATION", + "CONNECT", "CONNECTION", "CONNECTIONS", "CONSTRAINT", "CONTAINMENT", + "CONTAINS", "CONTENT", "CONTEXT", "CONTEXT_HEADERS", "CONTEXT_INFO", + "CONTINUE", "CONTROL", "CONVERSATION", "COOKIE", "COPY", "COPY_ONLY", + "COPY_OPTIONS_", "COUNT", "COUNT_BIG", "CREATE", "CREDENTIALS", "CREDIT_QUOTA", + "CROSS", "CSV", "CSV_Q", "CUBE", "CUME_DIST", "CURRENT", "CURRENT_DATE", + "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "CUSTOM", + "DAILY", "DATA", "DATABASE", "DATABASES", "DATA_RETENTION_TIME_IN_DAYS", + "DATEADD", "DATEDIFF", "DATENAME", "DATEPART", "DATE_FORMAT", "DATE_INPUT_FORMAT", + "DATE_OUTPUT_FORMAT", "DATE_PART", "DAYS", "DAYS_TO_EXPIRY", "DECLARE", + "DEFAULT", "DEFAULT_DDL_COLLATION_", "DEFAULT_NAMESPACE", "DEFAULT_ROLE", + "DEFAULT_WAREHOUSE", "DEFERRABLE", "DEFERRED", "DEFINE", "DEFINITION", + "DEFLATE", "DELEGATED", "DELETE", "DELTA", "DENSE_RANK", "DESC", "DESCRIBE", + "DIRECTION", "DIRECTORY", "DISABLE", "DISABLED", "DISABLE_AUTO_CONVERT", + "DISABLE_SNOWFLAKE_DATA", "DISK", "DISPLAY_NAME", "DISTINCT", "DO", + "DOWNSTREAM", "DOUBLE", "DROP", "DYNAMIC", "ECONOMY", "EDITION", "ELSE", + "EMAIL", "EMPTY_", "EMPTY_FIELD_AS_NULL", "ENABLE", "ENABLED", "ENABLE_FOR_PRIVILEGE", + "ENABLE_INTERNAL_STAGES_PRIVATELINK", "ENABLE_OCTAL", "ENABLE_QUERY_ACCELERATION", + "ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION", "ENCODING", "ENCRYPTION", + "END", "ENDPOINT", "END_TIMESTAMP", "ENFORCED", "ENFORCE_LENGTH", "ENFORCE_SESSION_POLICY", + "ENTERPRISE", "EQUALITY", "ERROR_INTEGRATION", "ERROR_ON_COLUMN_COUNT_MISMATCH", + "ERROR_ON_NONDETERMINISTIC_MERGE", "ERROR_ON_NONDETERMINISTIC_UPDATE", + "ESCAPE", "ESCAPE_UNENCLOSED_FIELD", "EXCEPT", "EXCHANGE", "EXECUTE", + "EXECUTION", "EXIST", "EXISTS", "EXIT", "EXPAND", "EXPIRY_DATE", "EXPLAIN", + "EXPLICIT", "EXTERNAL", "EXTERNAL_OAUTH", "EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST", + "EXTERNAL_OAUTH_ALLOWED_ROLES_LIST", "EXTERNAL_OAUTH_ANY_ROLE_MODE", + "EXTERNAL_OAUTH_AUDIENCE_LIST", "EXTERNAL_OAUTH_BLOCKED_ROLES_LIST", + "EXTERNAL_OAUTH_ISSUER", "EXTERNAL_OAUTH_JWS_KEYS_URL", "EXTERNAL_OAUTH_RSA_PUBLIC_KEY", + "EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2", "EXTERNAL_OAUTH_SCOPE_DELIMITER", + "EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE", "EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM", + "EXTERNAL_OAUTH_TYPE", "EXTERNAL_STAGE", "FAILOVER", "FAILOVER_MODE", + "FAIL_OPERATION", "FALSE", "FETCH", "FIELD_DELIMITER", "FIELD_OPTIONALLY_ENCLOSED_BY", + "FILE", "FILES", "FILE_EXTENSION", "FILE_FORMAT", "FILTER", "FIRST", + "FIRST_NAME", "FLATTEN", "FOR", "FORCE", "FOREIGN", "FORMAT", "FORMATS", + "FORMAT_NAME", "FREQUENCY", "FROM", "FULL", "FUNCTION", "FUNCTIONS", + "FUTURE", "GCP_PUBSUB", "GCP_PUBSUB_SUBSCRIPTION_NAME", "GCP_PUBSUB_TOPIC_NAME", + "GCS", "GENERIC_Q", "GENERIC_SCIM_PROVISIONER_Q", "GEO", "GEOGRAPHY_OUTPUT_FORMAT", + "GEOMETRY_OUTPUT_FORMAT", "GET", "GET_FILESTREAM_TRANSACTION_CONTEXT", + "GLOBAL", "GOOGLE_AUDIENCE", "GOTO", "GRANT", "GRANTS", "GROUP", "GROUPING", + "GROUPING_ID", "GROUPS", "GZIP", "HAVING", "HEADER", "HEADERS", "HEX", + "HIERARCHYID", "HIGH", "HISTORY", "HOURS", "IDENTITY", "IF", "IFF", + "IFNULL", "IGNORE", "IGNORE_CONSTRAINTS", "IGNORE_DUP_KEY", "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX", + "IGNORE_TRIGGERS", "IGNORE_UTF8_ERRORS", "ILIKE", "IMMEDIATE", "IMMEDIATELY", + "IMMUTABLE", "IMPLICIT", "IMPORT", "IMPORTED", "IN", "INCREMENT", "INDEX", + "INFORMATION", "INIT", "INITIALLY", "INITIALLY_SUSPENDED", "INITIAL_REPLICATION_SIZE_LIMIT_IN_TB", + "INNER", "INPUT", "INSERT", "INSERT_ONLY", "INSTEAD", "INT", "INTEGRATION", + "INTEGRATIONS", "INTERSECT", "INTO", "IS", "ISNULL", "ISNUMERIC", "ISOLATION", + "JAVASCRIPT", "JDBC_TREAT_DECIMAL_AS_INT", "JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC", + "JDBC_USE_SESSION_TIMEZONE", "JOIN", "JSON", "JSON_Q", "JSON_INDENT", + "JS_TREAT_INTEGER_AS_BIGINT", "KB", "KEEP", "KEY", "KEYS", "KEYSET", + "KMS_KEY_ID", "LAG", "LANGUAGE", "LARGE", "LAST", "LAST_NAME", "LAST_QUERY_ID", + "LAST_VALUE", "LATERAL", "LEAD", "LEFT", "LEN", "LENGTH", "LEVEL", "LIKE", + "LIMIT", "LINENO", "LIST", "LISTENER_IP", "LISTENER_PORT", "LISTING", + "LOAD", "LOCAL", "LOCAL_SERVICE_NAME", "LOCATION", "LOCKS", "LOCK_TIMEOUT", + "LOG", "LOGIN", "LOGIN_NAME", "LOOKER", "LOW", "LOWER", "LTRIM", "LZO", + "MANAGE", "MANAGED", "MASK", "MASKED", "MASKING", "MASTER", "MASTER_KEY", + "MATCH", "MATCHED", "MATCHES", "MATCH_BY_COLUMN_NAME", "MATCH_RECOGNIZE", + "MATERIALIZED", "MAX_BATCH_ROWS", "MAX_CLUSTER_COUNT", "MAX_CONCURRENCY_LEVEL", + "MAX_DATA_EXTENSION_TIME_IN_DAYS", "MAX_SIZE", "MEASURES", "MEDIUM", + "MEMOIZABLE", "MERGE", "MIDDLE_NAME", "MIN", "MINS_TO_BYPASS_MFA", "MINS_TO_UNLOCK", + "MINUS_", "MINUTES", "MIN_CLUSTER_COUNT", "MIN_DATA_RETENTION_TIME_IN_DAYS", + "MODE", "MODIFIED_AFTER", "MODIFY", "MONITOR", "MONITORS", "MONTHLY", + "MOVE", "MULTI_STATEMENT_COUNT", "MULTI_USER", "MUST_CHANGE", "MUST_CHANGE_PASSWORD", + "NAME", "NATURAL", "NCHAR", "NESTED_TRIGGERS", "NETWORK", "NETWORK_POLICY", + "NEVER", "NEWID", "NEWNAME", "NEWSEQUENTIALID", "NEW_ACCOUNT", "NEW_BROKER", + "NEW_PASSWORD", "NEXT", "NEXTVAL", "NO", "NONE", "NONE_Q", "NORELY", + "NOT", "NOTIFICATION", "NOTIFICATIONS", "NOTIFICATION_INTEGRATION", + "NOTIFICATION_PROVIDER", "NOTIFY", "NOTIFY_USERS", "NOVALIDATE", "NTILE", + "NULLIF", "NULLS", "NULL_", "NULL_IF", "NUMANODE", "NUMBER", "NUMERIC_ROUNDABORT", + "NVL", "OAUTH", "OAUTH_ALLOW_NON_TLS_REDIRECT_URI", "OAUTH_CLIENT", + "OAUTH_CLIENT_RSA_PUBLIC_KEY", "OAUTH_CLIENT_RSA_PUBLIC_KEY_2", "OAUTH_ENFORCE_PKCE", + "OAUTH_ISSUE_REFRESH_TOKENS", "OAUTH_REDIRECT_URI", "OAUTH_REFRESH_TOKEN_VALIDITY", + "OAUTH_USE_SECONDARY_ROLES", "OBJECT", "OBJECT_Q", "OBJECTS", "OBJECT_TYPES", + "OF", "OFF", "OFFSET", "OFFSETS", "OKTA", "OKTA_PROVISIONER_Q", "OKTA_Q", + "OLD", "OLD_ACCOUNT", "OLD_PASSWORD", "OMIT", "ON", "ONE", "ONLINE", + "ONLY", "ON_ERROR", "ON_FAILURE", "OPEN", "OPERATE", "OPERATIONS", "OPTIMIZATION", + "OPTION", "OR", "ORC", "ORC_Q", "ORDER", "ORGADMIN", "ORGANIZATION", + "OUTBOUND", "OUTER", "OVER", "OVERRIDE", "OVERWRITE", "OWNER", "OWNERSHIP", + "PAGE", "PARALLEL", "PARAMETERS", "PARAM_NODE", "PARQUET", "PARQUET_Q", + "PARTIAL", "PARTITION", "PARTITIONS", "PARTITION_TYPE", "PASSWORD", + "PAST", "PATH_", "PATTERN", "PER", "PERCENT", "PERCENTILE_CONT", "PERCENTILE_DISC", + "PERCENT_RANK", "PERIODIC_DATA_REKEYING", "PERMISSION_SET", "PERSISTED", + "PERSIST_SAMPLE_PERCENT", "PING_FEDERATE", "PIPE", "PIPES", "PIPE_EXECUTION_PAUSED", + "PIVOT", "PLAN", "PLATFORM", "POLICIES", "POLICY", "POOL", "PORT", "PRECEDING", + "PRECISION", "PREDICATE", "PREFIX", "PRESERVE_SPACE", "PREVENT_UNLOAD_TO_INLINE_URL", + "PREVENT_UNLOAD_TO_INTERNAL_STAGES", "PRE_AUTHORIZED_ROLES_LIST", "PRIMARY", + "PRIMARY_ROLE", "PRIOR", "PRIORITY", "PRIORITY_LEVEL", "PRIVATE", "PRIVATE_KEY", + "PRIVILEGES", "PROC", "PROCEDURE", "PROCEDURES", "PROCEDURE_NAME", "PROCESS", + "PROFILE", "PROPERTY", "PROVIDER", "PROVIDER_KEY_NAME", "PUBLIC", "PURGE", + "PUT", "PYTHON", "QUALIFY", "QUERIES", "QUERY", "QUERY_ACCELERATION_MAX_SCALE_FACTOR", + "QUERY_TAG", "QUEUE", "QUOTED_IDENTIFIERS_IGNORE_CASE", "RANGE", "RANK", + "RAW_DEFLATE", "READ", "READER", "READONLY", "READPAST", "READTEXT", + "READWRITE", "READ_COMMITTED_SNAPSHOT", "READ_ONLY", "READ_ONLY_ROUTING_LIST", + "READ_WRITE", "REBUILD", "RECEIVE", "RECLUSTER", "RECOMPILE", "RECONFIGURE", + "RECORD_DELIMITER", "RECOVERY", "RECURSIVE", "RECURSIVE_TRIGGERS", "REFERENCES", + "REFERENCE_USAGE", "REFRESH", "REFRESH_ON_CREATE", "REGION", "REGIONS", + "REGION_GROUP", "RELATIVE", "RELY", "REMOTE", "REMOTE_PROC_TRANSACTIONS", + "REMOTE_SERVICE_NAME", "REMOVE", "RENAME", "REPEATABLE", "REPLACE", + "REPLACE_INVALID_CHARACTERS", "REPLICA", "REPLICATION", "REPLICATION_SCHEDULE", + "REQUEST_TRANSLATOR", "REQUIRED", "REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION", + "REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION", "RESET", "RESOURCE", + "RESOURCES", "RESOURCE_MONITOR", "RESPONSE_TRANSLATOR", "RESTART", "RESTORE", + "RESTRICT", "RESTRICTIONS", "RESULT", "RESUME", "RETAINDAYS", "RETURN", + "RETURNS", "RETURN_ALL_ERRORS", "RETURN_ERRORS", "RETURN_FAILED_ONLY", + "RETURN_N_ROWS", "RETURN_ROWS", "REVERSE", "REVERT", "REVOKE", "REWIND", + "RIGHT", "RLIKE", "ROLE", "ROLES", "ROLLBACK", "ROLLUP", "ROOT", "ROW", + "ROWCOUNT", "ROWGUID", "ROWLOCK", "ROWS", "ROWS_PER_RESULTSET", "ROW_NUMBER", + "RSA_PUBLIC_KEY", "RSA_PUBLIC_KEY_2", "RTRIM", "RUN_AS_ROLE", "S3", + "SAFE", "SAFETY", "SAML2", "SAML2_ENABLE_SP_INITIATED", "SAML2_FORCE_AUTHN", + "SAML2_ISSUER", "SAML2_POST_LOGOUT_REDIRECT_URL", "SAML2_PROVIDER", + "SAML2_REQUESTED_NAMEID_FORMAT", "SAML2_SIGN_REQUEST", "SAML2_SNOWFLAKE_ACS_URL", + "SAML2_SNOWFLAKE_ISSUER_URL", "SAML2_SNOWFLAKE_X509_CERT", "SAML2_SP_INITIATED_LOGIN_PAGE_LABEL", + "SAML2_SSO_URL", "SAML2_X509_CERT", "SAML_IDENTITY_PROVIDER", "SAMPLE", + "SAVE_OLD_URL", "SCALING_POLICY", "SCHEDULE", "SCHEDULER", "SCHEMA", + "SCHEMAS", "SCHEME", "SCIM", "SCIM_CLIENT", "SCRIPT", "SEARCH", "SECONDARY", + "SECONDARY_ONLY", "SECONDARY_ROLE", "SECONDS", "SECRET", "SECURE", "SECURITY", + "SECURITYADMIN", "SEED", "SELECT", "SELF", "SEQUENCE", "SEQUENCES", + "SERVER", "SERVICE", "SESSION", "SESSION_IDLE_TIMEOUT_MINS", "SESSION_POLICY", + "SESSION_UI_IDLE_TIMEOUT_MINS", "SET", "SETS", "SETUSER", "SHARE", "SHARED", + "SHARES", "SHARE_RESTRICTIONS", "SHOW", "SHOWPLAN", "SHOWPLAN_ALL", + "SHOWPLAN_TEXT", "SHOWPLAN_XML", "SHOW_INITIAL_ROWS", "SIGNATURE", "SIMPLE", + "SIMULATED_DATA_SHARING_CONSUMER", "SINGLE_USER", "SIZE", "SIZE_LIMIT", + "SKIP_", "SKIP_BLANK_LINES", "SKIP_BYTE_ORDER_MARK", "SKIP_FILE", "SKIP_FILE_N", + "SKIP_HEADER", "SMALL", "SNAPPY", "SNAPPY_COMPRESSION", "SOME", "SOUNDEX", + "SOURCE", "SOURCE_COMPRESSION", "SPACE_KEYWORD", "SPARSE", "SPECIFICATION", + "SPLIT", "SPLIT_PART", "SQL", "SSO_LOGIN_PAGE", "STAGE", "STAGES", "STAGE_COPY_OPTIONS", + "STAGE_FILE_FORMAT", "STANDARD", "STANDBY", "START", "STARTED", "STARTS", + "START_DATE", "START_TIMESTAMP", "STATE", "STATEMENT", "STATEMENT_QUEUED_TIMEOUT_IN_SECONDS", + "STATEMENT_TIMEOUT_IN_SECONDS", "STATIC", "STATISTICS", "STATS", "STATS_DATE", + "STATS_STREAM", "STATUS", "STATUSONLY", "STDEV", "STDEVP", "STOP", "STOPLIST", + "STOPPED", "STORAGE", "STORAGE_ALLOWED_LOCATIONS", "STORAGE_AWS_OBJECT_ACL", + "STORAGE_AWS_ROLE_ARN", "STORAGE_BLOCKED_LOCATIONS", "STORAGE_INTEGRATION", + "STORAGE_PROVIDER", "STR", "STREAM", "STREAMS", "STRICT", "STRICT_JSON_OUTPUT", + "STRING_AGG", "STRING_ESCAPE", "STRIP_NULL_VALUES", "STRIP_OUTER_ARRAY", + "STRIP_OUTER_ELEMENT", "SUBSTR", "SUBSTRING", "SUM", "SUPPORTED", "SUSPEND", + "SUSPENDED", "SUSPEND_IMMEDIATE", "SUSPEND_TASK_AFTER_NUM_FAILURES", + "SWAP", "SWITCH", "SYNC_PASSWORD", "SYSADMIN", "SYSTEM", "SYSTEM_USER", + "TABLE", "TABLEAU_DESKTOP", "TABLEAU_SERVER", "TABLES", "TABLESAMPLE", + "TABLE_FORMAT", "TABULAR", "TAG", "TAGS", "TARGET", "TARGET_LAG", "TASK", + "TASKS", "TEMP", "TEMPORARY", "TERSE", "TEXTSIZE", "THEN", "TIES", "TIME", + "TIMEADD", "TIMEDIFF", "TIMEOUT", "TIMER", "TIMESTAMP", "TIMESTAMP_DAY_IS_ALWAYS_24H", + "TIMESTAMP_FORMAT", "TIMESTAMP_INPUT_FORMAT", "TIMESTAMP_LTZ", "TIMESTAMP_LTZ_OUTPUT_FORMAT", + "TIMESTAMP_NTZ", "TIMESTAMP_NTZ_OUTPUT_FORMAT", "TIMESTAMP_OUTPUT_FORMAT", + "TIMESTAMP_TYPE_MAPPING", "TIMESTAMP_TZ", "TIMESTAMP_TZ_OUTPUT_FORMAT", + "TIMESTAMPADD", "TIMESTAMPDIFF", "TIMEZONE", "TIME_FORMAT", "TIME_INPUT_FORMAT", + "TIME_OUTPUT_FORMAT", "TO", "TO_BOOLEAN", "TO_DATE", "TOP", "TORN_PAGE_DETECTION", + "TRACKING", "TRACK_CAUSALITY", "TRAN", "TRANSACTION", "TRANSACTIONS", + "TRANSACTION_ABORT_ON_ERROR", "TRANSACTION_DEFAULT_ISOLATION_LEVEL", + "TRANSACTION_ID", "TRANSFORM_NOISE_WORDS", "TRANSIENT", "TRANSLATE", + "TRIGGER", "TRIGGERS", "TRIM", "TRIM_SPACE", "TRIPLE_DES", "TRIPLE_DES_3KEY", + "TRUE", "TRUNCATE", "TRUNCATECOLUMNS", "TRUSTWORTHY", "TRY", "TRY_CAST", + "TSEQUAL", "TSQL", "TWO_DIGIT_CENTURY_START", "TWO_DIGIT_YEAR_CUTOFF", + "TYPE", "TYPEPROPERTY", "TYPE_ID", "TYPE_NAME", "TYPE_WARNING", "UN", + "UNBOUNDED", "UNCHECKED", "UNCOMMITTED", "UNDROP", "UNICODE", "UNION", + "UNIQUE", "UNKNOWN", "UNLIMITED", "UNLOCK", "UNMASK", "UNMATCHED", "UNPIVOT", + "UNSAFE", "UNSET", "UNSUPPORTED_DDL_ACTION", "UOW", "UPDATE", "UPDLOCK", + "UPPER", "URL", "USAGE", "USE", "USED", "USER", "USERADMIN", "USERS", + "USER_SPECIFIED", "USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE", "USER_TASK_TIMEOUT_MS", + "USE_ANY_ROLE", "USE_CACHED_RESULT", "USING", "UTF8", "VALIDATE", "VALIDATION", + "VALIDATION_MODE", "VALID_XML", "VALUE", "VALUES", "VAR", "VARIABLES", + "VARP", "VARYING", "VERSION", "VIEW", "VIEWS", "VIEW_METADATA", "VISIBILITY", + "VOLATILE", "WAIT", "WAREHOUSE", "WAREHOUSES", "WAREHOUSE_SIZE", "WEEKLY", + "WEEK_OF_YEAR_POLICY", "WEEK_START", "WELL_FORMED_XML", "WHEN", "WHERE", + "WITH", "WITHIN", "WITHOUT", "WITHOUT_ARRAY_WRAPPER", "WORK", "WORKLOAD", + "WRITE", "X4LARGE", "X5LARGE", "X6LARGE", "XLARGE", "XLOCK", "XML", + "XML_Q", "XSMALL", "XXLARGE", "XXXLARGE", "YEARLY", "ZSTD", "ARRAY", + "ARRAY_Q", "BIGINT", "BINARY", "BOOLEAN", "BYTEINT", "CHAR_VARYING", + "DATE", "DATETIME", "DECIMAL_", "FLOAT4", "FLOAT8", "FLOAT_", "GEOGRAPHY", + "GEOMETRY", "INTEGER", "NCHAR_VARYING", "NUMERIC", "NVARCHAR2", "NVARCHAR", + "REAL_", "SMALLINT", "STRING_", "TEXT", "TINYINT", "VARBINARY", "VARCHAR", + "VARIANT", "LISTAGG", "DUMMY", "SPACE", "SQL_COMMENT", "LINE_COMMENT", + "LINE_COMMENT_2", "DOUBLE_QUOTE_ID", "DOUBLE_QUOTE_BLANK", "SINGLE_QUOTE", + "ID", "ID2", "S3_PATH", "GCS_PATH", "AZURE_PATH", "FILE_PATH", "DBL_DOLLAR", + "STRING", "DECIMAL", "FLOAT", "REAL", "CHAR_LITERAL", "ARROW", "ASSOC", + "NE", "LTGT", "EQ", "GT", "GE", "LT", "LE", "EXCLAMATION", "PIPE_PIPE", + "DOT", "UNDERLINE", "AT", "AT_Q", "DOLLAR", "LR_BRACKET", "RR_BRACKET", + "LSB", "RSB", "LCB", "RCB", "COMMA", "SEMI", "COLON", "COLON_COLON", + "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "PLACEHOLDER", + } + staticData.RuleNames = []string{ + "AAD_PROVISIONER_Q", "ABORT", "ABORT_AFTER_WAIT", "ABORT_DETACHED_QUERY", + "ABORT_STATEMENT", "ABSENT", "ABSOLUTE", "ACCESS", "ACCOUNT", "ACCOUNTADMIN", + "ACCOUNTS", "ACTION", "ACTIVE", "ADD", "ADMINISTER", "ADMIN_NAME", "ADMIN_PASSWORD", + "AES", "AFTER", "AGGREGATE", "ALERT", "ALERTS", "ALL", "ALLOWED", "ALLOWED_ACCOUNTS", + "ALLOWED_DATABASES", "ALLOWED_INTEGRATION_TYPES", "ALLOWED_IP_LIST", + "ALLOWED_SHARES", "ALLOWED_VALUES", "ALLOW_CLIENT_MFA_CACHING", "ALLOW_CONNECTIONS", + "ALLOW_DUPLICATE", "ALLOW_ID_TOKEN", "ALLOW_MULTIPLE_EVENT_LOSS", "ALLOW_OVERLAPPING_EXECUTION", + "ALLOW_SINGLE_EVENT_LOSS", "ALTER", "ALWAYS", "AND", "ANONYMOUS", "ANSI_DEFAULTS", + "ANY", "API", "API_ALLOWED_PREFIXES", "API_AWS_ROLE_ARN", "API_BLOCKED_PREFIXES", + "API_INTEGRATION", "API_KEY", "API_PROVIDER", "APPEND", "APPEND_ONLY", + "APPLICATION", "APPLY", "APP_NAME", "AS", "ASC", "ATTACH", "AT_KEYWORD", + "AUTHORIZATION", "AUTHORIZATIONS", "AUTO", "AUTO_Q", "AUTOCOMMIT", "AUTOCOMMIT_API_SUPPORTED", + "AUTOINCREMENT", "AUTO_COMPRESS", "AUTO_DETECT", "AUTO_INGEST", "AUTO_REFRESH", + "AUTO_RESUME", "AUTO_SUSPEND", "AVG", "AVRO", "AVRO_Q", "AWS_KEY_ID", + "AWS_ROLE", "AWS_SECRET_KEY", "AWS_SNS", "AWS_SNS_ROLE_ARN", "AWS_SNS_TOPIC", + "AWS_SNS_TOPIC_ARN", "AWS_TOKEN", "AZURE", "AZURE_AD_APPLICATION_ID", + "AZURE_EVENT_GRID", "AZURE_EVENT_GRID_TOPIC_ENDPOINT", "AZURE_Q", "AZURE_SAS_TOKEN", + "AZURE_STORAGE_QUEUE_PRIMARY_URI", "AZURE_TENANT_ID", "BASE64", "BEFORE", + "BEGIN", "BERNOULLI", "BETWEEN", "BINARY_AS_TEXT", "BINARY_CHECKSUM", + "BINARY_FORMAT", "BINARY_INPUT_FORMAT", "BINARY_OUTPUT_FORMAT", "BINDING", + "BLOCK", "BLOCKED_IP_LIST", "BLOCKED_ROLES_LIST", "BODY", "BOTH_Q", + "BROTLI", "BUSINESS_CRITICAL", "BY", "BZ2", "CACHE", "CALL", "CALLED", + "CALLER", "CASCADE", "CASE", "CASE_INSENSITIVE", "CASE_SENSITIVE", "CAST", + "CATCH", "CERTIFICATE", "CHANGE", "CHANGES", "CHANGETABLE", "CHANGE_RETENTION", + "CHANGE_TRACKING", "CHAR", "CHARACTER", "CHARINDEX", "CHECK", "CHECKSUM", + "CHECKSUM_AGG", "CHECK_EXPIRATION", "CHECK_POLICY", "CLASSIFIER_FUNCTION", + "CLEANUP", "CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS", "CLIENT_ENCRYPTION_KEY_SIZE", + "CLIENT_MEMORY_LIMIT", "CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX", + "CLIENT_METADATA_USE_SESSION_DATABASE", "CLIENT_PREFETCH_THREADS", "CLIENT_RESULT_CHUNK_SIZE", + "CLIENT_RESULT_COLUMN_CASE_INSENSITIVE", "CLIENT_SESSION_KEEP_ALIVE", + "CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY", "CLIENT_TIMESTAMP_TYPE_MAPPING", + "CLONE", "CLOSE", "CLUSTER", "CLUSTERED", "CLUSTERING", "COALESCE", + "COLLATE", "COLLECTION", "COLUMN", "COLUMNS", "COL_LENGTH", "COL_NAME", + "COMMENT", "COMMIT", "COMMITTED", "COMPRESS", "COMPRESSION", "CONCAT", + "CONCAT_NULL_YIELDS_NULL", "CONCAT_WS", "CONDITION", "CONFIGURATION", + "CONNECT", "CONNECTION", "CONNECTIONS", "CONSTRAINT", "CONTAINMENT", + "CONTAINS", "CONTENT", "CONTEXT", "CONTEXT_HEADERS", "CONTEXT_INFO", + "CONTINUE", "CONTROL", "CONVERSATION", "COOKIE", "COPY", "COPY_ONLY", + "COPY_OPTIONS_", "COUNT", "COUNT_BIG", "CREATE", "CREDENTIALS", "CREDIT_QUOTA", + "CROSS", "CSV", "CSV_Q", "CUBE", "CUME_DIST", "CURRENT", "CURRENT_DATE", + "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "CUSTOM", + "DAILY", "DATA", "DATABASE", "DATABASES", "DATA_RETENTION_TIME_IN_DAYS", + "DATEADD", "DATEDIFF", "DATENAME", "DATEPART", "DATE_FORMAT", "DATE_INPUT_FORMAT", + "DATE_OUTPUT_FORMAT", "DATE_PART", "DAYS", "DAYS_TO_EXPIRY", "DECLARE", + "DEFAULT", "DEFAULT_DDL_COLLATION_", "DEFAULT_NAMESPACE", "DEFAULT_ROLE", + "DEFAULT_WAREHOUSE", "DEFERRABLE", "DEFERRED", "DEFINE", "DEFINITION", + "DEFLATE", "DELEGATED", "DELETE", "DELTA", "DENSE_RANK", "DESC", "DESCRIBE", + "DIRECTION", "DIRECTORY", "DISABLE", "DISABLED", "DISABLE_AUTO_CONVERT", + "DISABLE_SNOWFLAKE_DATA", "DISK", "DISPLAY_NAME", "DISTINCT", "DO", + "DOWNSTREAM", "DOUBLE", "DROP", "DYNAMIC", "ECONOMY", "EDITION", "ELSE", + "EMAIL", "EMPTY_", "EMPTY_FIELD_AS_NULL", "ENABLE", "ENABLED", "ENABLE_FOR_PRIVILEGE", + "ENABLE_INTERNAL_STAGES_PRIVATELINK", "ENABLE_OCTAL", "ENABLE_QUERY_ACCELERATION", + "ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION", "ENCODING", "ENCRYPTION", + "END", "ENDPOINT", "END_TIMESTAMP", "ENFORCED", "ENFORCE_LENGTH", "ENFORCE_SESSION_POLICY", + "ENTERPRISE", "EQUALITY", "ERROR_INTEGRATION", "ERROR_ON_COLUMN_COUNT_MISMATCH", + "ERROR_ON_NONDETERMINISTIC_MERGE", "ERROR_ON_NONDETERMINISTIC_UPDATE", + "ESCAPE", "ESCAPE_UNENCLOSED_FIELD", "EXCEPT", "EXCHANGE", "EXECUTE", + "EXECUTION", "EXIST", "EXISTS", "EXIT", "EXPAND", "EXPIRY_DATE", "EXPLAIN", + "EXPLICIT", "EXTERNAL", "EXTERNAL_OAUTH", "EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST", + "EXTERNAL_OAUTH_ALLOWED_ROLES_LIST", "EXTERNAL_OAUTH_ANY_ROLE_MODE", + "EXTERNAL_OAUTH_AUDIENCE_LIST", "EXTERNAL_OAUTH_BLOCKED_ROLES_LIST", + "EXTERNAL_OAUTH_ISSUER", "EXTERNAL_OAUTH_JWS_KEYS_URL", "EXTERNAL_OAUTH_RSA_PUBLIC_KEY", + "EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2", "EXTERNAL_OAUTH_SCOPE_DELIMITER", + "EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE", "EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM", + "EXTERNAL_OAUTH_TYPE", "EXTERNAL_STAGE", "FAILOVER", "FAILOVER_MODE", + "FAIL_OPERATION", "FALSE", "FETCH", "FIELD_DELIMITER", "FIELD_OPTIONALLY_ENCLOSED_BY", + "FILE", "FILES", "FILE_EXTENSION", "FILE_FORMAT", "FILTER", "FIRST", + "FIRST_NAME", "FLATTEN", "FOR", "FORCE", "FOREIGN", "FORMAT", "FORMATS", + "FORMAT_NAME", "FREQUENCY", "FROM", "FULL", "FUNCTION", "FUNCTIONS", + "FUTURE", "GCP_PUBSUB", "GCP_PUBSUB_SUBSCRIPTION_NAME", "GCP_PUBSUB_TOPIC_NAME", + "GCS", "GENERIC_Q", "GENERIC_SCIM_PROVISIONER_Q", "GEO", "GEOGRAPHY_OUTPUT_FORMAT", + "GEOMETRY_OUTPUT_FORMAT", "GET", "GET_FILESTREAM_TRANSACTION_CONTEXT", + "GLOBAL", "GOOGLE_AUDIENCE", "GOTO", "GRANT", "GRANTS", "GROUP", "GROUPING", + "GROUPING_ID", "GROUPS", "GZIP", "HAVING", "HEADER", "HEADERS", "HEX", + "HIERARCHYID", "HIGH", "HISTORY", "HOURS", "IDENTITY", "IF", "IFF", + "IFNULL", "IGNORE", "IGNORE_CONSTRAINTS", "IGNORE_DUP_KEY", "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX", + "IGNORE_TRIGGERS", "IGNORE_UTF8_ERRORS", "ILIKE", "IMMEDIATE", "IMMEDIATELY", + "IMMUTABLE", "IMPLICIT", "IMPORT", "IMPORTED", "IN", "INCREMENT", "INDEX", + "INFORMATION", "INIT", "INITIALLY", "INITIALLY_SUSPENDED", "INITIAL_REPLICATION_SIZE_LIMIT_IN_TB", + "INNER", "INPUT", "INSERT", "INSERT_ONLY", "INSTEAD", "INT", "INTEGRATION", + "INTEGRATIONS", "INTERSECT", "INTO", "IS", "ISNULL", "ISNUMERIC", "ISOLATION", + "JAVASCRIPT", "JDBC_TREAT_DECIMAL_AS_INT", "JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC", + "JDBC_USE_SESSION_TIMEZONE", "JOIN", "JSON", "JSON_Q", "JSON_INDENT", + "JS_TREAT_INTEGER_AS_BIGINT", "KB", "KEEP", "KEY", "KEYS", "KEYSET", + "KMS_KEY_ID", "LAG", "LANGUAGE", "LARGE", "LAST", "LAST_NAME", "LAST_QUERY_ID", + "LAST_VALUE", "LATERAL", "LEAD", "LEFT", "LEN", "LENGTH", "LEVEL", "LIKE", + "LIMIT", "LINENO", "LIST", "LISTENER_IP", "LISTENER_PORT", "LISTING", + "LOAD", "LOCAL", "LOCAL_SERVICE_NAME", "LOCATION", "LOCKS", "LOCK_TIMEOUT", + "LOG", "LOGIN", "LOGIN_NAME", "LOOKER", "LOW", "LOWER", "LTRIM", "LZO", + "MANAGE", "MANAGED", "MASK", "MASKED", "MASKING", "MASTER", "MASTER_KEY", + "MATCH", "MATCHED", "MATCHES", "MATCH_BY_COLUMN_NAME", "MATCH_RECOGNIZE", + "MATERIALIZED", "MAX_BATCH_ROWS", "MAX_CLUSTER_COUNT", "MAX_CONCURRENCY_LEVEL", + "MAX_DATA_EXTENSION_TIME_IN_DAYS", "MAX_SIZE", "MEASURES", "MEDIUM", + "MEMOIZABLE", "MERGE", "MIDDLE_NAME", "MIN", "MINS_TO_BYPASS_MFA", "MINS_TO_UNLOCK", + "MINUS_", "MINUTES", "MIN_CLUSTER_COUNT", "MIN_DATA_RETENTION_TIME_IN_DAYS", + "MODE", "MODIFIED_AFTER", "MODIFY", "MONITOR", "MONITORS", "MONTHLY", + "MOVE", "MULTI_STATEMENT_COUNT", "MULTI_USER", "MUST_CHANGE", "MUST_CHANGE_PASSWORD", + "NAME", "NATURAL", "NCHAR", "NESTED_TRIGGERS", "NETWORK", "NETWORK_POLICY", + "NEVER", "NEWID", "NEWNAME", "NEWSEQUENTIALID", "NEW_ACCOUNT", "NEW_BROKER", + "NEW_PASSWORD", "NEXT", "NEXTVAL", "NO", "NONE", "NONE_Q", "NORELY", + "NOT", "NOTIFICATION", "NOTIFICATIONS", "NOTIFICATION_INTEGRATION", + "NOTIFICATION_PROVIDER", "NOTIFY", "NOTIFY_USERS", "NOVALIDATE", "NTILE", + "NULLIF", "NULLS", "NULL_", "NULL_IF", "NUMANODE", "NUMBER", "NUMERIC_ROUNDABORT", + "NVL", "OAUTH", "OAUTH_ALLOW_NON_TLS_REDIRECT_URI", "OAUTH_CLIENT", + "OAUTH_CLIENT_RSA_PUBLIC_KEY", "OAUTH_CLIENT_RSA_PUBLIC_KEY_2", "OAUTH_ENFORCE_PKCE", + "OAUTH_ISSUE_REFRESH_TOKENS", "OAUTH_REDIRECT_URI", "OAUTH_REFRESH_TOKEN_VALIDITY", + "OAUTH_USE_SECONDARY_ROLES", "OBJECT", "OBJECT_Q", "OBJECTS", "OBJECT_TYPES", + "OF", "OFF", "OFFSET", "OFFSETS", "OKTA", "OKTA_PROVISIONER_Q", "OKTA_Q", + "OLD", "OLD_ACCOUNT", "OLD_PASSWORD", "OMIT", "ON", "ONE", "ONLINE", + "ONLY", "ON_ERROR", "ON_FAILURE", "OPEN", "OPERATE", "OPERATIONS", "OPTIMIZATION", + "OPTION", "OR", "ORC", "ORC_Q", "ORDER", "ORGADMIN", "ORGANIZATION", + "OUTBOUND", "OUTER", "OVER", "OVERRIDE", "OVERWRITE", "OWNER", "OWNERSHIP", + "PAGE", "PARALLEL", "PARAMETERS", "PARAM_NODE", "PARQUET", "PARQUET_Q", + "PARTIAL", "PARTITION", "PARTITIONS", "PARTITION_TYPE", "PASSWORD", + "PAST", "PATH_", "PATTERN", "PER", "PERCENT", "PERCENTILE_CONT", "PERCENTILE_DISC", + "PERCENT_RANK", "PERIODIC_DATA_REKEYING", "PERMISSION_SET", "PERSISTED", + "PERSIST_SAMPLE_PERCENT", "PING_FEDERATE", "PIPE", "PIPES", "PIPE_EXECUTION_PAUSED", + "PIVOT", "PLAN", "PLATFORM", "POLICIES", "POLICY", "POOL", "PORT", "PRECEDING", + "PRECISION", "PREDICATE", "PREFIX", "PRESERVE_SPACE", "PREVENT_UNLOAD_TO_INLINE_URL", + "PREVENT_UNLOAD_TO_INTERNAL_STAGES", "PRE_AUTHORIZED_ROLES_LIST", "PRIMARY", + "PRIMARY_ROLE", "PRIOR", "PRIORITY", "PRIORITY_LEVEL", "PRIVATE", "PRIVATE_KEY", + "PRIVILEGES", "PROC", "PROCEDURE", "PROCEDURES", "PROCEDURE_NAME", "PROCESS", + "PROFILE", "PROPERTY", "PROVIDER", "PROVIDER_KEY_NAME", "PUBLIC", "PURGE", + "PUT", "PYTHON", "QUALIFY", "QUERIES", "QUERY", "QUERY_ACCELERATION_MAX_SCALE_FACTOR", + "QUERY_TAG", "QUEUE", "QUOTED_IDENTIFIERS_IGNORE_CASE", "RANGE", "RANK", + "RAW_DEFLATE", "READ", "READER", "READONLY", "READPAST", "READTEXT", + "READWRITE", "READ_COMMITTED_SNAPSHOT", "READ_ONLY", "READ_ONLY_ROUTING_LIST", + "READ_WRITE", "REBUILD", "RECEIVE", "RECLUSTER", "RECOMPILE", "RECONFIGURE", + "RECORD_DELIMITER", "RECOVERY", "RECURSIVE", "RECURSIVE_TRIGGERS", "REFERENCES", + "REFERENCE_USAGE", "REFRESH", "REFRESH_ON_CREATE", "REGION", "REGIONS", + "REGION_GROUP", "RELATIVE", "RELY", "REMOTE", "REMOTE_PROC_TRANSACTIONS", + "REMOTE_SERVICE_NAME", "REMOVE", "RENAME", "REPEATABLE", "REPLACE", + "REPLACE_INVALID_CHARACTERS", "REPLICA", "REPLICATION", "REPLICATION_SCHEDULE", + "REQUEST_TRANSLATOR", "REQUIRED", "REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION", + "REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION", "RESET", "RESOURCE", + "RESOURCES", "RESOURCE_MONITOR", "RESPONSE_TRANSLATOR", "RESTART", "RESTORE", + "RESTRICT", "RESTRICTIONS", "RESULT", "RESUME", "RETAINDAYS", "RETURN", + "RETURNS", "RETURN_ALL_ERRORS", "RETURN_ERRORS", "RETURN_FAILED_ONLY", + "RETURN_N_ROWS", "RETURN_ROWS", "REVERSE", "REVERT", "REVOKE", "REWIND", + "RIGHT", "RLIKE", "ROLE", "ROLES", "ROLLBACK", "ROLLUP", "ROOT", "ROW", + "ROWCOUNT", "ROWGUID", "ROWLOCK", "ROWS", "ROWS_PER_RESULTSET", "ROW_NUMBER", + "RSA_PUBLIC_KEY", "RSA_PUBLIC_KEY_2", "RTRIM", "RUN_AS_ROLE", "S3", + "SAFE", "SAFETY", "SAML2", "SAML2_ENABLE_SP_INITIATED", "SAML2_FORCE_AUTHN", + "SAML2_ISSUER", "SAML2_POST_LOGOUT_REDIRECT_URL", "SAML2_PROVIDER", + "SAML2_REQUESTED_NAMEID_FORMAT", "SAML2_SIGN_REQUEST", "SAML2_SNOWFLAKE_ACS_URL", + "SAML2_SNOWFLAKE_ISSUER_URL", "SAML2_SNOWFLAKE_X509_CERT", "SAML2_SP_INITIATED_LOGIN_PAGE_LABEL", + "SAML2_SSO_URL", "SAML2_X509_CERT", "SAML_IDENTITY_PROVIDER", "SAMPLE", + "SAVE_OLD_URL", "SCALING_POLICY", "SCHEDULE", "SCHEDULER", "SCHEMA", + "SCHEMAS", "SCHEME", "SCIM", "SCIM_CLIENT", "SCRIPT", "SEARCH", "SECONDARY", + "SECONDARY_ONLY", "SECONDARY_ROLE", "SECONDS", "SECRET", "SECURE", "SECURITY", + "SECURITYADMIN", "SEED", "SELECT", "SELF", "SEQUENCE", "SEQUENCES", + "SERVER", "SERVICE", "SESSION", "SESSION_IDLE_TIMEOUT_MINS", "SESSION_POLICY", + "SESSION_UI_IDLE_TIMEOUT_MINS", "SET", "SETS", "SETUSER", "SHARE", "SHARED", + "SHARES", "SHARE_RESTRICTIONS", "SHOW", "SHOWPLAN", "SHOWPLAN_ALL", + "SHOWPLAN_TEXT", "SHOWPLAN_XML", "SHOW_INITIAL_ROWS", "SIGNATURE", "SIMPLE", + "SIMULATED_DATA_SHARING_CONSUMER", "SINGLE_USER", "SIZE", "SIZE_LIMIT", + "SKIP_", "SKIP_BLANK_LINES", "SKIP_BYTE_ORDER_MARK", "SKIP_FILE", "SKIP_FILE_N", + "SKIP_HEADER", "SMALL", "SNAPPY", "SNAPPY_COMPRESSION", "SOME", "SOUNDEX", + "SOURCE", "SOURCE_COMPRESSION", "SPACE_KEYWORD", "SPARSE", "SPECIFICATION", + "SPLIT", "SPLIT_PART", "SQL", "SSO_LOGIN_PAGE", "STAGE", "STAGES", "STAGE_COPY_OPTIONS", + "STAGE_FILE_FORMAT", "STANDARD", "STANDBY", "START", "STARTED", "STARTS", + "START_DATE", "START_TIMESTAMP", "STATE", "STATEMENT", "STATEMENT_QUEUED_TIMEOUT_IN_SECONDS", + "STATEMENT_TIMEOUT_IN_SECONDS", "STATIC", "STATISTICS", "STATS", "STATS_DATE", + "STATS_STREAM", "STATUS", "STATUSONLY", "STDEV", "STDEVP", "STOP", "STOPLIST", + "STOPPED", "STORAGE", "STORAGE_ALLOWED_LOCATIONS", "STORAGE_AWS_OBJECT_ACL", + "STORAGE_AWS_ROLE_ARN", "STORAGE_BLOCKED_LOCATIONS", "STORAGE_INTEGRATION", + "STORAGE_PROVIDER", "STR", "STREAM", "STREAMS", "STRICT", "STRICT_JSON_OUTPUT", + "STRING_AGG", "STRING_ESCAPE", "STRIP_NULL_VALUES", "STRIP_OUTER_ARRAY", + "STRIP_OUTER_ELEMENT", "SUBSTR", "SUBSTRING", "SUM", "SUPPORTED", "SUSPEND", + "SUSPENDED", "SUSPEND_IMMEDIATE", "SUSPEND_TASK_AFTER_NUM_FAILURES", + "SWAP", "SWITCH", "SYNC_PASSWORD", "SYSADMIN", "SYSTEM", "SYSTEM_USER", + "TABLE", "TABLEAU_DESKTOP", "TABLEAU_SERVER", "TABLES", "TABLESAMPLE", + "TABLE_FORMAT", "TABULAR", "TAG", "TAGS", "TARGET", "TARGET_LAG", "TASK", + "TASKS", "TEMP", "TEMPORARY", "TERSE", "TEXTSIZE", "THEN", "TIES", "TIME", + "TIMEADD", "TIMEDIFF", "TIMEOUT", "TIMER", "TIMESTAMP", "TIMESTAMP_DAY_IS_ALWAYS_24H", + "TIMESTAMP_FORMAT", "TIMESTAMP_INPUT_FORMAT", "TIMESTAMP_LTZ", "TIMESTAMP_LTZ_OUTPUT_FORMAT", + "TIMESTAMP_NTZ", "TIMESTAMP_NTZ_OUTPUT_FORMAT", "TIMESTAMP_OUTPUT_FORMAT", + "TIMESTAMP_TYPE_MAPPING", "TIMESTAMP_TZ", "TIMESTAMP_TZ_OUTPUT_FORMAT", + "TIMESTAMPADD", "TIMESTAMPDIFF", "TIMEZONE", "TIME_FORMAT", "TIME_INPUT_FORMAT", + "TIME_OUTPUT_FORMAT", "TO", "TO_BOOLEAN", "TO_DATE", "TOP", "TORN_PAGE_DETECTION", + "TRACKING", "TRACK_CAUSALITY", "TRAN", "TRANSACTION", "TRANSACTIONS", + "TRANSACTION_ABORT_ON_ERROR", "TRANSACTION_DEFAULT_ISOLATION_LEVEL", + "TRANSACTION_ID", "TRANSFORM_NOISE_WORDS", "TRANSIENT", "TRANSLATE", + "TRIGGER", "TRIGGERS", "TRIM", "TRIM_SPACE", "TRIPLE_DES", "TRIPLE_DES_3KEY", + "TRUE", "TRUNCATE", "TRUNCATECOLUMNS", "TRUSTWORTHY", "TRY", "TRY_CAST", + "TSEQUAL", "TSQL", "TWO_DIGIT_CENTURY_START", "TWO_DIGIT_YEAR_CUTOFF", + "TYPE", "TYPEPROPERTY", "TYPE_ID", "TYPE_NAME", "TYPE_WARNING", "UN", + "UNBOUNDED", "UNCHECKED", "UNCOMMITTED", "UNDROP", "UNICODE", "UNION", + "UNIQUE", "UNKNOWN", "UNLIMITED", "UNLOCK", "UNMASK", "UNMATCHED", "UNPIVOT", + "UNSAFE", "UNSET", "UNSUPPORTED_DDL_ACTION", "UOW", "UPDATE", "UPDLOCK", + "UPPER", "URL", "USAGE", "USE", "USED", "USER", "USERADMIN", "USERS", + "USER_SPECIFIED", "USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE", "USER_TASK_TIMEOUT_MS", + "USE_ANY_ROLE", "USE_CACHED_RESULT", "USING", "UTF8", "VALIDATE", "VALIDATION", + "VALIDATION_MODE", "VALID_XML", "VALUE", "VALUES", "VAR", "VARIABLES", + "VARP", "VARYING", "VERSION", "VIEW", "VIEWS", "VIEW_METADATA", "VISIBILITY", + "VOLATILE", "WAIT", "WAREHOUSE", "WAREHOUSES", "WAREHOUSE_SIZE", "WEEKLY", + "WEEK_OF_YEAR_POLICY", "WEEK_START", "WELL_FORMED_XML", "WHEN", "WHERE", + "WITH", "WITHIN", "WITHOUT", "WITHOUT_ARRAY_WRAPPER", "WORK", "WORKLOAD", + "WRITE", "X4LARGE", "X5LARGE", "X6LARGE", "XLARGE", "XLOCK", "XML", + "XML_Q", "XSMALL", "XXLARGE", "XXXLARGE", "YEARLY", "ZSTD", "ARRAY", + "ARRAY_Q", "BIGINT", "BINARY", "BOOLEAN", "BYTEINT", "CHAR_VARYING", + "DATE", "DATETIME", "DECIMAL_", "FLOAT4", "FLOAT8", "FLOAT_", "GEOGRAPHY", + "GEOMETRY", "INTEGER", "NCHAR_VARYING", "NUMERIC", "NVARCHAR2", "NVARCHAR", + "REAL_", "SMALLINT", "STRING_", "TEXT", "TINYINT", "VARBINARY", "VARCHAR", + "VARIANT", "LISTAGG", "DUMMY", "SPACE", "SQL_COMMENT", "LINE_COMMENT", + "LINE_COMMENT_2", "DOUBLE_QUOTE_ID", "DOUBLE_QUOTE_BLANK", "SINGLE_QUOTE", + "ID", "ID2", "S3_PATH", "GCS_PATH", "AZURE_PATH", "FILE_PATH", "DBL_DOLLAR", + "STRING", "DECIMAL", "FLOAT", "REAL", "CHAR_LITERAL", "EscapeSequence", + "HexDigit", "ARROW", "ASSOC", "NE", "LTGT", "EQ", "GT", "GE", "LT", + "LE", "EXCLAMATION", "PIPE_PIPE", "DOT", "UNDERLINE", "AT", "AT_Q", + "DOLLAR", "LR_BRACKET", "RR_BRACKET", "LSB", "RSB", "LCB", "RCB", "COMMA", + "SEMI", "COLON", "COLON_COLON", "STAR", "DIVIDE", "MODULE", "PLUS", + "MINUS", "PLACEHOLDER", "LETTER", "DEC_DOT_DEC", "DEC_DIGIT", "FullWidthLetter", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 1119, 14939, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, + 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, + 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, + 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, + 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, + 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, + 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, + 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, + 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, + 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, + 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, + 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, + 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, + 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, + 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, + 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, + 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, + 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, + 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, + 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, + 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, + 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, + 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, + 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, + 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, + 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, + 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, + 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, + 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, + 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, + 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, + 153, 7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, + 157, 2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, + 162, 7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, + 166, 2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, + 171, 7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, + 175, 2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, + 180, 7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, + 184, 2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, + 189, 7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, + 193, 2, 194, 7, 194, 2, 195, 7, 195, 2, 196, 7, 196, 2, 197, 7, 197, 2, + 198, 7, 198, 2, 199, 7, 199, 2, 200, 7, 200, 2, 201, 7, 201, 2, 202, 7, + 202, 2, 203, 7, 203, 2, 204, 7, 204, 2, 205, 7, 205, 2, 206, 7, 206, 2, + 207, 7, 207, 2, 208, 7, 208, 2, 209, 7, 209, 2, 210, 7, 210, 2, 211, 7, + 211, 2, 212, 7, 212, 2, 213, 7, 213, 2, 214, 7, 214, 2, 215, 7, 215, 2, + 216, 7, 216, 2, 217, 7, 217, 2, 218, 7, 218, 2, 219, 7, 219, 2, 220, 7, + 220, 2, 221, 7, 221, 2, 222, 7, 222, 2, 223, 7, 223, 2, 224, 7, 224, 2, + 225, 7, 225, 2, 226, 7, 226, 2, 227, 7, 227, 2, 228, 7, 228, 2, 229, 7, + 229, 2, 230, 7, 230, 2, 231, 7, 231, 2, 232, 7, 232, 2, 233, 7, 233, 2, + 234, 7, 234, 2, 235, 7, 235, 2, 236, 7, 236, 2, 237, 7, 237, 2, 238, 7, + 238, 2, 239, 7, 239, 2, 240, 7, 240, 2, 241, 7, 241, 2, 242, 7, 242, 2, + 243, 7, 243, 2, 244, 7, 244, 2, 245, 7, 245, 2, 246, 7, 246, 2, 247, 7, + 247, 2, 248, 7, 248, 2, 249, 7, 249, 2, 250, 7, 250, 2, 251, 7, 251, 2, + 252, 7, 252, 2, 253, 7, 253, 2, 254, 7, 254, 2, 255, 7, 255, 2, 256, 7, + 256, 2, 257, 7, 257, 2, 258, 7, 258, 2, 259, 7, 259, 2, 260, 7, 260, 2, + 261, 7, 261, 2, 262, 7, 262, 2, 263, 7, 263, 2, 264, 7, 264, 2, 265, 7, + 265, 2, 266, 7, 266, 2, 267, 7, 267, 2, 268, 7, 268, 2, 269, 7, 269, 2, + 270, 7, 270, 2, 271, 7, 271, 2, 272, 7, 272, 2, 273, 7, 273, 2, 274, 7, + 274, 2, 275, 7, 275, 2, 276, 7, 276, 2, 277, 7, 277, 2, 278, 7, 278, 2, + 279, 7, 279, 2, 280, 7, 280, 2, 281, 7, 281, 2, 282, 7, 282, 2, 283, 7, + 283, 2, 284, 7, 284, 2, 285, 7, 285, 2, 286, 7, 286, 2, 287, 7, 287, 2, + 288, 7, 288, 2, 289, 7, 289, 2, 290, 7, 290, 2, 291, 7, 291, 2, 292, 7, + 292, 2, 293, 7, 293, 2, 294, 7, 294, 2, 295, 7, 295, 2, 296, 7, 296, 2, + 297, 7, 297, 2, 298, 7, 298, 2, 299, 7, 299, 2, 300, 7, 300, 2, 301, 7, + 301, 2, 302, 7, 302, 2, 303, 7, 303, 2, 304, 7, 304, 2, 305, 7, 305, 2, + 306, 7, 306, 2, 307, 7, 307, 2, 308, 7, 308, 2, 309, 7, 309, 2, 310, 7, + 310, 2, 311, 7, 311, 2, 312, 7, 312, 2, 313, 7, 313, 2, 314, 7, 314, 2, + 315, 7, 315, 2, 316, 7, 316, 2, 317, 7, 317, 2, 318, 7, 318, 2, 319, 7, + 319, 2, 320, 7, 320, 2, 321, 7, 321, 2, 322, 7, 322, 2, 323, 7, 323, 2, + 324, 7, 324, 2, 325, 7, 325, 2, 326, 7, 326, 2, 327, 7, 327, 2, 328, 7, + 328, 2, 329, 7, 329, 2, 330, 7, 330, 2, 331, 7, 331, 2, 332, 7, 332, 2, + 333, 7, 333, 2, 334, 7, 334, 2, 335, 7, 335, 2, 336, 7, 336, 2, 337, 7, + 337, 2, 338, 7, 338, 2, 339, 7, 339, 2, 340, 7, 340, 2, 341, 7, 341, 2, + 342, 7, 342, 2, 343, 7, 343, 2, 344, 7, 344, 2, 345, 7, 345, 2, 346, 7, + 346, 2, 347, 7, 347, 2, 348, 7, 348, 2, 349, 7, 349, 2, 350, 7, 350, 2, + 351, 7, 351, 2, 352, 7, 352, 2, 353, 7, 353, 2, 354, 7, 354, 2, 355, 7, + 355, 2, 356, 7, 356, 2, 357, 7, 357, 2, 358, 7, 358, 2, 359, 7, 359, 2, + 360, 7, 360, 2, 361, 7, 361, 2, 362, 7, 362, 2, 363, 7, 363, 2, 364, 7, + 364, 2, 365, 7, 365, 2, 366, 7, 366, 2, 367, 7, 367, 2, 368, 7, 368, 2, + 369, 7, 369, 2, 370, 7, 370, 2, 371, 7, 371, 2, 372, 7, 372, 2, 373, 7, + 373, 2, 374, 7, 374, 2, 375, 7, 375, 2, 376, 7, 376, 2, 377, 7, 377, 2, + 378, 7, 378, 2, 379, 7, 379, 2, 380, 7, 380, 2, 381, 7, 381, 2, 382, 7, + 382, 2, 383, 7, 383, 2, 384, 7, 384, 2, 385, 7, 385, 2, 386, 7, 386, 2, + 387, 7, 387, 2, 388, 7, 388, 2, 389, 7, 389, 2, 390, 7, 390, 2, 391, 7, + 391, 2, 392, 7, 392, 2, 393, 7, 393, 2, 394, 7, 394, 2, 395, 7, 395, 2, + 396, 7, 396, 2, 397, 7, 397, 2, 398, 7, 398, 2, 399, 7, 399, 2, 400, 7, + 400, 2, 401, 7, 401, 2, 402, 7, 402, 2, 403, 7, 403, 2, 404, 7, 404, 2, + 405, 7, 405, 2, 406, 7, 406, 2, 407, 7, 407, 2, 408, 7, 408, 2, 409, 7, + 409, 2, 410, 7, 410, 2, 411, 7, 411, 2, 412, 7, 412, 2, 413, 7, 413, 2, + 414, 7, 414, 2, 415, 7, 415, 2, 416, 7, 416, 2, 417, 7, 417, 2, 418, 7, + 418, 2, 419, 7, 419, 2, 420, 7, 420, 2, 421, 7, 421, 2, 422, 7, 422, 2, + 423, 7, 423, 2, 424, 7, 424, 2, 425, 7, 425, 2, 426, 7, 426, 2, 427, 7, + 427, 2, 428, 7, 428, 2, 429, 7, 429, 2, 430, 7, 430, 2, 431, 7, 431, 2, + 432, 7, 432, 2, 433, 7, 433, 2, 434, 7, 434, 2, 435, 7, 435, 2, 436, 7, + 436, 2, 437, 7, 437, 2, 438, 7, 438, 2, 439, 7, 439, 2, 440, 7, 440, 2, + 441, 7, 441, 2, 442, 7, 442, 2, 443, 7, 443, 2, 444, 7, 444, 2, 445, 7, + 445, 2, 446, 7, 446, 2, 447, 7, 447, 2, 448, 7, 448, 2, 449, 7, 449, 2, + 450, 7, 450, 2, 451, 7, 451, 2, 452, 7, 452, 2, 453, 7, 453, 2, 454, 7, + 454, 2, 455, 7, 455, 2, 456, 7, 456, 2, 457, 7, 457, 2, 458, 7, 458, 2, + 459, 7, 459, 2, 460, 7, 460, 2, 461, 7, 461, 2, 462, 7, 462, 2, 463, 7, + 463, 2, 464, 7, 464, 2, 465, 7, 465, 2, 466, 7, 466, 2, 467, 7, 467, 2, + 468, 7, 468, 2, 469, 7, 469, 2, 470, 7, 470, 2, 471, 7, 471, 2, 472, 7, + 472, 2, 473, 7, 473, 2, 474, 7, 474, 2, 475, 7, 475, 2, 476, 7, 476, 2, + 477, 7, 477, 2, 478, 7, 478, 2, 479, 7, 479, 2, 480, 7, 480, 2, 481, 7, + 481, 2, 482, 7, 482, 2, 483, 7, 483, 2, 484, 7, 484, 2, 485, 7, 485, 2, + 486, 7, 486, 2, 487, 7, 487, 2, 488, 7, 488, 2, 489, 7, 489, 2, 490, 7, + 490, 2, 491, 7, 491, 2, 492, 7, 492, 2, 493, 7, 493, 2, 494, 7, 494, 2, + 495, 7, 495, 2, 496, 7, 496, 2, 497, 7, 497, 2, 498, 7, 498, 2, 499, 7, + 499, 2, 500, 7, 500, 2, 501, 7, 501, 2, 502, 7, 502, 2, 503, 7, 503, 2, + 504, 7, 504, 2, 505, 7, 505, 2, 506, 7, 506, 2, 507, 7, 507, 2, 508, 7, + 508, 2, 509, 7, 509, 2, 510, 7, 510, 2, 511, 7, 511, 2, 512, 7, 512, 2, + 513, 7, 513, 2, 514, 7, 514, 2, 515, 7, 515, 2, 516, 7, 516, 2, 517, 7, + 517, 2, 518, 7, 518, 2, 519, 7, 519, 2, 520, 7, 520, 2, 521, 7, 521, 2, + 522, 7, 522, 2, 523, 7, 523, 2, 524, 7, 524, 2, 525, 7, 525, 2, 526, 7, + 526, 2, 527, 7, 527, 2, 528, 7, 528, 2, 529, 7, 529, 2, 530, 7, 530, 2, + 531, 7, 531, 2, 532, 7, 532, 2, 533, 7, 533, 2, 534, 7, 534, 2, 535, 7, + 535, 2, 536, 7, 536, 2, 537, 7, 537, 2, 538, 7, 538, 2, 539, 7, 539, 2, + 540, 7, 540, 2, 541, 7, 541, 2, 542, 7, 542, 2, 543, 7, 543, 2, 544, 7, + 544, 2, 545, 7, 545, 2, 546, 7, 546, 2, 547, 7, 547, 2, 548, 7, 548, 2, + 549, 7, 549, 2, 550, 7, 550, 2, 551, 7, 551, 2, 552, 7, 552, 2, 553, 7, + 553, 2, 554, 7, 554, 2, 555, 7, 555, 2, 556, 7, 556, 2, 557, 7, 557, 2, + 558, 7, 558, 2, 559, 7, 559, 2, 560, 7, 560, 2, 561, 7, 561, 2, 562, 7, + 562, 2, 563, 7, 563, 2, 564, 7, 564, 2, 565, 7, 565, 2, 566, 7, 566, 2, + 567, 7, 567, 2, 568, 7, 568, 2, 569, 7, 569, 2, 570, 7, 570, 2, 571, 7, + 571, 2, 572, 7, 572, 2, 573, 7, 573, 2, 574, 7, 574, 2, 575, 7, 575, 2, + 576, 7, 576, 2, 577, 7, 577, 2, 578, 7, 578, 2, 579, 7, 579, 2, 580, 7, + 580, 2, 581, 7, 581, 2, 582, 7, 582, 2, 583, 7, 583, 2, 584, 7, 584, 2, + 585, 7, 585, 2, 586, 7, 586, 2, 587, 7, 587, 2, 588, 7, 588, 2, 589, 7, + 589, 2, 590, 7, 590, 2, 591, 7, 591, 2, 592, 7, 592, 2, 593, 7, 593, 2, + 594, 7, 594, 2, 595, 7, 595, 2, 596, 7, 596, 2, 597, 7, 597, 2, 598, 7, + 598, 2, 599, 7, 599, 2, 600, 7, 600, 2, 601, 7, 601, 2, 602, 7, 602, 2, + 603, 7, 603, 2, 604, 7, 604, 2, 605, 7, 605, 2, 606, 7, 606, 2, 607, 7, + 607, 2, 608, 7, 608, 2, 609, 7, 609, 2, 610, 7, 610, 2, 611, 7, 611, 2, + 612, 7, 612, 2, 613, 7, 613, 2, 614, 7, 614, 2, 615, 7, 615, 2, 616, 7, + 616, 2, 617, 7, 617, 2, 618, 7, 618, 2, 619, 7, 619, 2, 620, 7, 620, 2, + 621, 7, 621, 2, 622, 7, 622, 2, 623, 7, 623, 2, 624, 7, 624, 2, 625, 7, + 625, 2, 626, 7, 626, 2, 627, 7, 627, 2, 628, 7, 628, 2, 629, 7, 629, 2, + 630, 7, 630, 2, 631, 7, 631, 2, 632, 7, 632, 2, 633, 7, 633, 2, 634, 7, + 634, 2, 635, 7, 635, 2, 636, 7, 636, 2, 637, 7, 637, 2, 638, 7, 638, 2, + 639, 7, 639, 2, 640, 7, 640, 2, 641, 7, 641, 2, 642, 7, 642, 2, 643, 7, + 643, 2, 644, 7, 644, 2, 645, 7, 645, 2, 646, 7, 646, 2, 647, 7, 647, 2, + 648, 7, 648, 2, 649, 7, 649, 2, 650, 7, 650, 2, 651, 7, 651, 2, 652, 7, + 652, 2, 653, 7, 653, 2, 654, 7, 654, 2, 655, 7, 655, 2, 656, 7, 656, 2, + 657, 7, 657, 2, 658, 7, 658, 2, 659, 7, 659, 2, 660, 7, 660, 2, 661, 7, + 661, 2, 662, 7, 662, 2, 663, 7, 663, 2, 664, 7, 664, 2, 665, 7, 665, 2, + 666, 7, 666, 2, 667, 7, 667, 2, 668, 7, 668, 2, 669, 7, 669, 2, 670, 7, + 670, 2, 671, 7, 671, 2, 672, 7, 672, 2, 673, 7, 673, 2, 674, 7, 674, 2, + 675, 7, 675, 2, 676, 7, 676, 2, 677, 7, 677, 2, 678, 7, 678, 2, 679, 7, + 679, 2, 680, 7, 680, 2, 681, 7, 681, 2, 682, 7, 682, 2, 683, 7, 683, 2, + 684, 7, 684, 2, 685, 7, 685, 2, 686, 7, 686, 2, 687, 7, 687, 2, 688, 7, + 688, 2, 689, 7, 689, 2, 690, 7, 690, 2, 691, 7, 691, 2, 692, 7, 692, 2, + 693, 7, 693, 2, 694, 7, 694, 2, 695, 7, 695, 2, 696, 7, 696, 2, 697, 7, + 697, 2, 698, 7, 698, 2, 699, 7, 699, 2, 700, 7, 700, 2, 701, 7, 701, 2, + 702, 7, 702, 2, 703, 7, 703, 2, 704, 7, 704, 2, 705, 7, 705, 2, 706, 7, + 706, 2, 707, 7, 707, 2, 708, 7, 708, 2, 709, 7, 709, 2, 710, 7, 710, 2, + 711, 7, 711, 2, 712, 7, 712, 2, 713, 7, 713, 2, 714, 7, 714, 2, 715, 7, + 715, 2, 716, 7, 716, 2, 717, 7, 717, 2, 718, 7, 718, 2, 719, 7, 719, 2, + 720, 7, 720, 2, 721, 7, 721, 2, 722, 7, 722, 2, 723, 7, 723, 2, 724, 7, + 724, 2, 725, 7, 725, 2, 726, 7, 726, 2, 727, 7, 727, 2, 728, 7, 728, 2, + 729, 7, 729, 2, 730, 7, 730, 2, 731, 7, 731, 2, 732, 7, 732, 2, 733, 7, + 733, 2, 734, 7, 734, 2, 735, 7, 735, 2, 736, 7, 736, 2, 737, 7, 737, 2, + 738, 7, 738, 2, 739, 7, 739, 2, 740, 7, 740, 2, 741, 7, 741, 2, 742, 7, + 742, 2, 743, 7, 743, 2, 744, 7, 744, 2, 745, 7, 745, 2, 746, 7, 746, 2, + 747, 7, 747, 2, 748, 7, 748, 2, 749, 7, 749, 2, 750, 7, 750, 2, 751, 7, + 751, 2, 752, 7, 752, 2, 753, 7, 753, 2, 754, 7, 754, 2, 755, 7, 755, 2, + 756, 7, 756, 2, 757, 7, 757, 2, 758, 7, 758, 2, 759, 7, 759, 2, 760, 7, + 760, 2, 761, 7, 761, 2, 762, 7, 762, 2, 763, 7, 763, 2, 764, 7, 764, 2, + 765, 7, 765, 2, 766, 7, 766, 2, 767, 7, 767, 2, 768, 7, 768, 2, 769, 7, + 769, 2, 770, 7, 770, 2, 771, 7, 771, 2, 772, 7, 772, 2, 773, 7, 773, 2, + 774, 7, 774, 2, 775, 7, 775, 2, 776, 7, 776, 2, 777, 7, 777, 2, 778, 7, + 778, 2, 779, 7, 779, 2, 780, 7, 780, 2, 781, 7, 781, 2, 782, 7, 782, 2, + 783, 7, 783, 2, 784, 7, 784, 2, 785, 7, 785, 2, 786, 7, 786, 2, 787, 7, + 787, 2, 788, 7, 788, 2, 789, 7, 789, 2, 790, 7, 790, 2, 791, 7, 791, 2, + 792, 7, 792, 2, 793, 7, 793, 2, 794, 7, 794, 2, 795, 7, 795, 2, 796, 7, + 796, 2, 797, 7, 797, 2, 798, 7, 798, 2, 799, 7, 799, 2, 800, 7, 800, 2, + 801, 7, 801, 2, 802, 7, 802, 2, 803, 7, 803, 2, 804, 7, 804, 2, 805, 7, + 805, 2, 806, 7, 806, 2, 807, 7, 807, 2, 808, 7, 808, 2, 809, 7, 809, 2, + 810, 7, 810, 2, 811, 7, 811, 2, 812, 7, 812, 2, 813, 7, 813, 2, 814, 7, + 814, 2, 815, 7, 815, 2, 816, 7, 816, 2, 817, 7, 817, 2, 818, 7, 818, 2, + 819, 7, 819, 2, 820, 7, 820, 2, 821, 7, 821, 2, 822, 7, 822, 2, 823, 7, + 823, 2, 824, 7, 824, 2, 825, 7, 825, 2, 826, 7, 826, 2, 827, 7, 827, 2, + 828, 7, 828, 2, 829, 7, 829, 2, 830, 7, 830, 2, 831, 7, 831, 2, 832, 7, + 832, 2, 833, 7, 833, 2, 834, 7, 834, 2, 835, 7, 835, 2, 836, 7, 836, 2, + 837, 7, 837, 2, 838, 7, 838, 2, 839, 7, 839, 2, 840, 7, 840, 2, 841, 7, + 841, 2, 842, 7, 842, 2, 843, 7, 843, 2, 844, 7, 844, 2, 845, 7, 845, 2, + 846, 7, 846, 2, 847, 7, 847, 2, 848, 7, 848, 2, 849, 7, 849, 2, 850, 7, + 850, 2, 851, 7, 851, 2, 852, 7, 852, 2, 853, 7, 853, 2, 854, 7, 854, 2, + 855, 7, 855, 2, 856, 7, 856, 2, 857, 7, 857, 2, 858, 7, 858, 2, 859, 7, + 859, 2, 860, 7, 860, 2, 861, 7, 861, 2, 862, 7, 862, 2, 863, 7, 863, 2, + 864, 7, 864, 2, 865, 7, 865, 2, 866, 7, 866, 2, 867, 7, 867, 2, 868, 7, + 868, 2, 869, 7, 869, 2, 870, 7, 870, 2, 871, 7, 871, 2, 872, 7, 872, 2, + 873, 7, 873, 2, 874, 7, 874, 2, 875, 7, 875, 2, 876, 7, 876, 2, 877, 7, + 877, 2, 878, 7, 878, 2, 879, 7, 879, 2, 880, 7, 880, 2, 881, 7, 881, 2, + 882, 7, 882, 2, 883, 7, 883, 2, 884, 7, 884, 2, 885, 7, 885, 2, 886, 7, + 886, 2, 887, 7, 887, 2, 888, 7, 888, 2, 889, 7, 889, 2, 890, 7, 890, 2, + 891, 7, 891, 2, 892, 7, 892, 2, 893, 7, 893, 2, 894, 7, 894, 2, 895, 7, + 895, 2, 896, 7, 896, 2, 897, 7, 897, 2, 898, 7, 898, 2, 899, 7, 899, 2, + 900, 7, 900, 2, 901, 7, 901, 2, 902, 7, 902, 2, 903, 7, 903, 2, 904, 7, + 904, 2, 905, 7, 905, 2, 906, 7, 906, 2, 907, 7, 907, 2, 908, 7, 908, 2, + 909, 7, 909, 2, 910, 7, 910, 2, 911, 7, 911, 2, 912, 7, 912, 2, 913, 7, + 913, 2, 914, 7, 914, 2, 915, 7, 915, 2, 916, 7, 916, 2, 917, 7, 917, 2, + 918, 7, 918, 2, 919, 7, 919, 2, 920, 7, 920, 2, 921, 7, 921, 2, 922, 7, + 922, 2, 923, 7, 923, 2, 924, 7, 924, 2, 925, 7, 925, 2, 926, 7, 926, 2, + 927, 7, 927, 2, 928, 7, 928, 2, 929, 7, 929, 2, 930, 7, 930, 2, 931, 7, + 931, 2, 932, 7, 932, 2, 933, 7, 933, 2, 934, 7, 934, 2, 935, 7, 935, 2, + 936, 7, 936, 2, 937, 7, 937, 2, 938, 7, 938, 2, 939, 7, 939, 2, 940, 7, + 940, 2, 941, 7, 941, 2, 942, 7, 942, 2, 943, 7, 943, 2, 944, 7, 944, 2, + 945, 7, 945, 2, 946, 7, 946, 2, 947, 7, 947, 2, 948, 7, 948, 2, 949, 7, + 949, 2, 950, 7, 950, 2, 951, 7, 951, 2, 952, 7, 952, 2, 953, 7, 953, 2, + 954, 7, 954, 2, 955, 7, 955, 2, 956, 7, 956, 2, 957, 7, 957, 2, 958, 7, + 958, 2, 959, 7, 959, 2, 960, 7, 960, 2, 961, 7, 961, 2, 962, 7, 962, 2, + 963, 7, 963, 2, 964, 7, 964, 2, 965, 7, 965, 2, 966, 7, 966, 2, 967, 7, + 967, 2, 968, 7, 968, 2, 969, 7, 969, 2, 970, 7, 970, 2, 971, 7, 971, 2, + 972, 7, 972, 2, 973, 7, 973, 2, 974, 7, 974, 2, 975, 7, 975, 2, 976, 7, + 976, 2, 977, 7, 977, 2, 978, 7, 978, 2, 979, 7, 979, 2, 980, 7, 980, 2, + 981, 7, 981, 2, 982, 7, 982, 2, 983, 7, 983, 2, 984, 7, 984, 2, 985, 7, + 985, 2, 986, 7, 986, 2, 987, 7, 987, 2, 988, 7, 988, 2, 989, 7, 989, 2, + 990, 7, 990, 2, 991, 7, 991, 2, 992, 7, 992, 2, 993, 7, 993, 2, 994, 7, + 994, 2, 995, 7, 995, 2, 996, 7, 996, 2, 997, 7, 997, 2, 998, 7, 998, 2, + 999, 7, 999, 2, 1000, 7, 1000, 2, 1001, 7, 1001, 2, 1002, 7, 1002, 2, 1003, + 7, 1003, 2, 1004, 7, 1004, 2, 1005, 7, 1005, 2, 1006, 7, 1006, 2, 1007, + 7, 1007, 2, 1008, 7, 1008, 2, 1009, 7, 1009, 2, 1010, 7, 1010, 2, 1011, + 7, 1011, 2, 1012, 7, 1012, 2, 1013, 7, 1013, 2, 1014, 7, 1014, 2, 1015, + 7, 1015, 2, 1016, 7, 1016, 2, 1017, 7, 1017, 2, 1018, 7, 1018, 2, 1019, + 7, 1019, 2, 1020, 7, 1020, 2, 1021, 7, 1021, 2, 1022, 7, 1022, 2, 1023, + 7, 1023, 2, 1024, 7, 1024, 2, 1025, 7, 1025, 2, 1026, 7, 1026, 2, 1027, + 7, 1027, 2, 1028, 7, 1028, 2, 1029, 7, 1029, 2, 1030, 7, 1030, 2, 1031, + 7, 1031, 2, 1032, 7, 1032, 2, 1033, 7, 1033, 2, 1034, 7, 1034, 2, 1035, + 7, 1035, 2, 1036, 7, 1036, 2, 1037, 7, 1037, 2, 1038, 7, 1038, 2, 1039, + 7, 1039, 2, 1040, 7, 1040, 2, 1041, 7, 1041, 2, 1042, 7, 1042, 2, 1043, + 7, 1043, 2, 1044, 7, 1044, 2, 1045, 7, 1045, 2, 1046, 7, 1046, 2, 1047, + 7, 1047, 2, 1048, 7, 1048, 2, 1049, 7, 1049, 2, 1050, 7, 1050, 2, 1051, + 7, 1051, 2, 1052, 7, 1052, 2, 1053, 7, 1053, 2, 1054, 7, 1054, 2, 1055, + 7, 1055, 2, 1056, 7, 1056, 2, 1057, 7, 1057, 2, 1058, 7, 1058, 2, 1059, + 7, 1059, 2, 1060, 7, 1060, 2, 1061, 7, 1061, 2, 1062, 7, 1062, 2, 1063, + 7, 1063, 2, 1064, 7, 1064, 2, 1065, 7, 1065, 2, 1066, 7, 1066, 2, 1067, + 7, 1067, 2, 1068, 7, 1068, 2, 1069, 7, 1069, 2, 1070, 7, 1070, 2, 1071, + 7, 1071, 2, 1072, 7, 1072, 2, 1073, 7, 1073, 2, 1074, 7, 1074, 2, 1075, + 7, 1075, 2, 1076, 7, 1076, 2, 1077, 7, 1077, 2, 1078, 7, 1078, 2, 1079, + 7, 1079, 2, 1080, 7, 1080, 2, 1081, 7, 1081, 2, 1082, 7, 1082, 2, 1083, + 7, 1083, 2, 1084, 7, 1084, 2, 1085, 7, 1085, 2, 1086, 7, 1086, 2, 1087, + 7, 1087, 2, 1088, 7, 1088, 2, 1089, 7, 1089, 2, 1090, 7, 1090, 2, 1091, + 7, 1091, 2, 1092, 7, 1092, 2, 1093, 7, 1093, 2, 1094, 7, 1094, 2, 1095, + 7, 1095, 2, 1096, 7, 1096, 2, 1097, 7, 1097, 2, 1098, 7, 1098, 2, 1099, + 7, 1099, 2, 1100, 7, 1100, 2, 1101, 7, 1101, 2, 1102, 7, 1102, 2, 1103, + 7, 1103, 2, 1104, 7, 1104, 2, 1105, 7, 1105, 2, 1106, 7, 1106, 2, 1107, + 7, 1107, 2, 1108, 7, 1108, 2, 1109, 7, 1109, 2, 1110, 7, 1110, 2, 1111, + 7, 1111, 2, 1112, 7, 1112, 2, 1113, 7, 1113, 2, 1114, 7, 1114, 2, 1115, + 7, 1115, 2, 1116, 7, 1116, 2, 1117, 7, 1117, 2, 1118, 7, 1118, 2, 1119, + 7, 1119, 2, 1120, 7, 1120, 2, 1121, 7, 1121, 2, 1122, 7, 1122, 2, 1123, + 7, 1123, 2, 1124, 7, 1124, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, + 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, + 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 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, 5, 1, + 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, + 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, + 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, + 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, + 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, + 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, + 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, + 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, + 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 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, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, + 1, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, + 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, + 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, + 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, + 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, + 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, + 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, + 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, + 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 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, 29, 1, 29, 1, 29, 1, + 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, + 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, + 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, + 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, + 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, + 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, + 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, + 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, + 33, 1, 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, 1, 34, 1, 34, 1, 34, 1, 34, 1, + 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, + 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, + 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, + 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, + 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, + 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, + 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, + 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, + 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, + 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, + 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, + 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, + 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, + 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, + 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, + 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, + 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, + 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 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, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, + 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, + 1, 57, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, + 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, + 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, + 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, + 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, + 63, 1, 63, 1, 63, 1, 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, 65, 1, 65, 1, 65, + 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, + 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, + 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, + 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 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, 1, 70, + 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, + 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, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, + 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, + 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, + 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 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, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, + 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, + 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, + 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, + 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, + 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, + 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, + 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, + 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, + 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, 1, + 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, + 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, + 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, + 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, + 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, + 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, + 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, + 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, + 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, + 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, + 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, + 1, 97, 1, 97, 1, 97, 1, 97, 1, 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, 99, 1, 99, + 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, + 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, + 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, + 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, + 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, + 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, + 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, + 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, + 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, + 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, + 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, + 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, + 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, + 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, + 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, + 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, + 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, + 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, + 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, + 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, + 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, + 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, + 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, + 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, + 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, + 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, + 123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, + 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, + 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 1, 126, 1, 126, 1, + 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, + 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, + 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, + 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, + 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, + 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, + 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 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, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, + 133, 1, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, + 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, + 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, + 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 136, 1, + 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 137, 1, 137, 1, + 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, + 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, + 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, + 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, + 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, + 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, + 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 138, 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, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, + 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, + 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, + 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, + 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, + 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, + 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 142, 1, + 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, + 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, + 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, 143, 1, + 143, 1, 143, 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, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, + 144, 1, 144, 1, 144, 1, 144, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, + 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, + 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, + 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, + 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, + 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, + 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 148, 1, 148, 1, + 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, + 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, + 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, + 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, + 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, + 153, 1, 153, 1, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, + 154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, + 155, 1, 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, + 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, + 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, + 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, + 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, + 160, 1, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, + 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, + 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 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, 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, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, + 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, + 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, + 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, + 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, 170, 1, 170, 1, 170, 1, + 170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1, + 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 172, 1, 172, 1, + 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, + 172, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 173, 1, + 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 175, 1, 175, 1, 175, 1, + 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, 176, 1, + 176, 1, 176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, + 177, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, + 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, + 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, + 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1, 180, 1, 180, 1, + 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, + 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 182, 1, + 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, + 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, + 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, 185, 1, + 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, + 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 1, 187, 1, + 187, 1, 187, 1, 187, 1, 187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 188, 1, + 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, + 189, 1, 189, 1, 189, 1, 189, 1, 190, 1, 190, 1, 190, 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, + 191, 1, 191, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, + 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, + 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 196, 1, 196, 1, 196, 1, 196, 1, + 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 197, 1, 197, 1, 197, 1, + 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, + 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, 199, 1, + 199, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, + 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, + 200, 1, 200, 1, 200, 1, 200, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 201, 1, 202, 1, + 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, 1, + 203, 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, + 204, 1, 205, 1, 205, 1, 205, 1, 205, 1, 205, 1, 206, 1, 206, 1, 206, 1, + 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 207, 1, 207, 1, 207, 1, + 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 207, 1, 208, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, + 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 209, 1, + 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 210, 1, 210, 1, + 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 210, 1, 211, 1, 211, 1, + 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 211, 1, 212, 1, 212, 1, + 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, + 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, + 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 1, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, 216, 1, + 216, 1, 216, 1, 216, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 218, 1, + 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, + 218, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, + 219, 1, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, 220, 1, 220, 1, 220, 1, + 220, 1, 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, + 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 221, 1, 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, 223, 1, 223, 1, + 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, 223, 1, + 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, + 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, + 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, 225, 1, + 225, 1, 225, 1, 225, 1, 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 226, 1, + 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, 227, 1, + 227, 1, 227, 1, 228, 1, 228, 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, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, + 230, 1, 230, 1, 230, 1, 230, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, + 231, 1, 231, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 233, 1, + 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, + 233, 1, 234, 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 1, 235, 1, + 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 236, 1, 236, 1, 236, 1, + 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, + 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 238, 1, + 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, + 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 239, 1, 240, 1, 240, 1, + 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, + 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, + 240, 1, 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, 241, 1, 241, 1, 241, 1, + 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 242, 1, 242, 1, 242, 1, + 242, 1, 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, 244, 1, 244, 1, 244, 1, + 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, + 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, 246, 1, + 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 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, 250, 1, 250, 1, 250, 1, 250, 1, 250, 1, + 250, 1, 250, 1, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, + 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, 1, + 253, 1, 253, 1, 253, 1, 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, 255, 1, + 255, 1, 255, 1, 255, 1, 255, 1, 255, 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, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, + 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, + 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, 258, 1, + 258, 1, 258, 1, 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, 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, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, + 259, 1, 259, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, + 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 1, + 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, + 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, + 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, + 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, 263, 1, + 263, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, + 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, 1, 265, 1, 266, 1, 266, 1, + 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 1, 267, 1, 267, 1, + 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 1, + 267, 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, 268, 1, + 268, 1, 268, 1, 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, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, + 270, 1, 270, 1, 270, 1, 270, 1, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, + 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 272, 1, 272, 1, + 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 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, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, + 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, + 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, + 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, + 276, 1, 276, 1, 276, 1, 276, 1, 276, 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, 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, 1, 278, 1, + 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 278, 1, 279, 1, + 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 279, 1, 280, 1, 280, 1, 280, 1, + 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, 1, 281, 1, 281, 1, + 281, 1, 281, 1, 281, 1, 281, 1, 281, 3, 281, 5755, 8, 281, 1, 282, 1, 282, + 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 282, 1, 283, + 1, 283, 1, 283, 1, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, + 1, 284, 1, 284, 1, 284, 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, 287, 1, 287, 1, 287, + 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, 1, 287, + 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, + 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 289, 1, 290, + 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, 1, 291, + 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, + 1, 291, 1, 291, 1, 291, 1, 291, 1, 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, 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, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, + 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, + 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, + 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 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, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, + 1, 295, 1, 295, 1, 295, 1, 295, 1, 295, 1, 296, 1, 296, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 296, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, + 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, + 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 298, 1, 298, + 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, + 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, + 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 298, 1, 299, + 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, + 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, + 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, 1, 299, + 1, 299, 1, 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, + 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, + 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, + 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, + 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, + 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, + 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, 1, 301, + 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, + 1, 302, 1, 302, 1, 302, 1, 302, 1, 302, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, + 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, 1, 304, + 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, + 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 306, + 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, 307, + 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, + 1, 307, 1, 307, 1, 307, 1, 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, 1, 308, 1, 308, + 1, 308, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 310, 1, 310, + 1, 310, 1, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, + 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, + 1, 311, 1, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, + 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, + 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, 1, 312, + 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, 313, 1, 313, 1, 313, + 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, 315, + 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, 1, 315, + 1, 315, 1, 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, + 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, + 1, 317, 1, 317, 1, 317, 1, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, + 1, 318, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, + 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, + 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, + 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, + 1, 323, 1, 323, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, 1, 324, + 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 326, + 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, + 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, 1, 327, + 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 328, 1, 328, 1, 328, 1, 329, + 1, 329, 1, 329, 1, 329, 1, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 330, + 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, + 1, 331, 1, 331, 1, 331, 1, 331, 1, 331, 1, 332, 1, 332, 1, 332, 1, 332, + 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, + 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, + 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, + 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, + 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, + 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, + 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, + 1, 335, 1, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, 1, 337, + 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 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, 339, 1, 339, + 1, 339, 1, 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, 1, 340, 1, 340, 1, 340, 1, 340, + 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 340, 1, 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, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 343, + 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, + 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, + 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, + 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, 344, 1, 344, + 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, + 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, 1, 345, + 1, 345, 1, 345, 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, + 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, + 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, + 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, 1, 350, + 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, 1, 351, + 1, 351, 1, 351, 1, 351, 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, 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, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, + 1, 356, 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, 1, 358, + 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 358, 1, 359, + 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, 1, 360, 1, 360, 1, 360, 1, 360, + 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, 1, 361, + 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, 1, 362, + 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, + 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 1, 366, + 1, 366, 1, 366, 1, 366, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, + 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, 1, 367, + 1, 367, 1, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, + 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, 1, 368, + 1, 368, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, + 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, + 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, + 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, 1, 369, + 1, 369, 1, 369, 1, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, + 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, + 1, 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, + 1, 371, 1, 371, 1, 371, 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, 373, + 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, 1, 373, + 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, + 1, 375, 1, 375, 1, 375, 1, 375, 1, 376, 1, 376, 1, 376, 1, 376, 1, 376, + 1, 376, 1, 376, 1, 376, 1, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, + 1, 377, 1, 377, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, + 1, 378, 1, 378, 1, 379, 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, 381, 1, 381, 1, 381, + 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, + 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, 1, 384, + 1, 384, 1, 384, 1, 384, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, + 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, + 1, 385, 1, 385, 1, 385, 1, 385, 1, 385, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, + 1, 387, 1, 387, 1, 387, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, + 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 389, 1, 390, 1, 390, + 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, 1, 390, + 1, 390, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, 1, 391, + 1, 392, 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, + 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 394, 1, 394, + 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, + 1, 394, 1, 394, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, 1, 395, + 1, 395, 1, 395, 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 397, + 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, + 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, 1, 399, + 1, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, 1, 400, + 1, 400, 1, 400, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, 1, 401, + 1, 401, 1, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, + 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, + 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, 1, 402, + 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, + 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, + 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, + 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 404, + 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, + 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, + 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, + 1, 405, 1, 405, 1, 405, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 407, + 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 408, 1, 408, 1, 408, + 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, 1, 408, + 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, + 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, + 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, + 1, 410, 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 412, + 1, 412, 1, 412, 1, 412, 1, 413, 1, 413, 1, 413, 1, 413, 1, 413, 1, 414, + 1, 414, 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, 415, 1, 415, 1, 415, 1, 415, 1, 416, + 1, 416, 1, 416, 1, 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, + 1, 417, 1, 417, 1, 417, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, + 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 420, 1, 420, 1, 420, 1, 420, + 1, 420, 1, 420, 1, 420, 1, 420, 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, 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, 423, 1, 423, 1, 423, 1, 423, 1, 423, + 1, 423, 1, 423, 1, 423, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, + 1, 425, 1, 425, 1, 425, 1, 425, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, + 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 428, 1, 428, 1, 428, + 1, 428, 1, 428, 1, 428, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 430, + 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 431, 1, 431, 1, 431, 1, 431, + 1, 431, 1, 431, 1, 431, 1, 432, 1, 432, 1, 432, 1, 432, 1, 432, 1, 433, + 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, + 1, 433, 1, 433, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, + 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 1, 435, 1, 435, + 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 1, 436, + 1, 436, 1, 436, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 438, + 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, + 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, + 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, + 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 440, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, 1, 441, + 1, 441, 1, 442, 1, 442, 1, 442, 1, 442, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, + 1, 444, 1, 444, 1, 444, 1, 444, 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, + 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, + 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, + 1, 449, 1, 449, 1, 449, 1, 449, 1, 450, 1, 450, 1, 450, 1, 450, 1, 450, + 1, 450, 1, 450, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, + 1, 451, 1, 452, 1, 452, 1, 452, 1, 452, 1, 452, 1, 453, 1, 453, 1, 453, + 1, 453, 1, 453, 1, 453, 1, 453, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, + 1, 454, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, + 1, 455, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, + 1, 456, 1, 456, 1, 456, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, + 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 459, + 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 1, 460, 1, 460, + 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, + 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, 1, 460, + 1, 460, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, + 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 461, 1, 462, + 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, + 1, 462, 1, 462, 1, 462, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, + 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, 1, 463, + 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, + 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, + 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, + 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, + 1, 465, 1, 465, 1, 465, 1, 465, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, + 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, + 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, + 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, 1, 466, + 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, 1, 467, + 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, + 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 470, 1, 470, + 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, + 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 471, 1, 472, 1, 472, 1, 472, + 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, + 1, 473, 1, 473, 1, 473, 1, 473, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, + 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, + 1, 474, 1, 474, 1, 474, 1, 474, 1, 474, 1, 475, 1, 475, 1, 475, 1, 475, + 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, 1, 475, + 1, 475, 1, 475, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 476, 1, 477, + 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 478, 1, 478, + 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, + 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 478, 1, 479, 1, 479, + 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, + 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, + 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, 1, 479, + 1, 479, 1, 479, 1, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 481, + 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, + 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 482, 1, 482, 1, 482, 1, 482, + 1, 482, 1, 482, 1, 482, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, + 1, 483, 1, 483, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, + 1, 484, 1, 484, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, 1, 485, + 1, 485, 1, 486, 1, 486, 1, 486, 1, 486, 1, 486, 1, 487, 1, 487, 1, 487, + 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, + 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, 1, 487, + 1, 487, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, 1, 488, + 1, 488, 1, 488, 1, 488, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, + 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 489, 1, 490, 1, 490, 1, 490, + 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, + 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, 1, 490, + 1, 491, 1, 491, 1, 491, 1, 491, 1, 491, 1, 492, 1, 492, 1, 492, 1, 492, + 1, 492, 1, 492, 1, 492, 1, 492, 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, + 1, 493, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, + 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 495, + 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 495, 1, 496, 1, 496, + 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, 1, 496, + 1, 496, 1, 496, 1, 496, 1, 496, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, + 1, 497, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 499, 1, 499, + 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 499, 1, 500, 1, 500, 1, 500, + 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, + 1, 500, 1, 500, 1, 500, 1, 500, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, + 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 502, 1, 502, + 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, + 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, + 1, 503, 1, 503, 1, 503, 1, 503, 1, 504, 1, 504, 1, 504, 1, 504, 1, 504, + 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 1, 506, + 1, 506, 1, 506, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 508, 1, 508, + 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, + 1, 509, 1, 509, 1, 509, 1, 510, 1, 510, 1, 510, 1, 510, 1, 511, 1, 511, + 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, + 1, 511, 1, 511, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, + 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 513, 1, 513, + 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, + 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, + 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 514, + 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, + 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, 1, 514, + 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, + 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, + 1, 516, 1, 516, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 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, 1, 519, 1, 519, 1, 519, 1, 519, 1, 520, + 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 521, 1, 521, 1, 521, 1, 521, + 1, 521, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, + 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, + 1, 524, 1, 524, 1, 524, 1, 524, 1, 524, 1, 524, 1, 524, 1, 525, 1, 525, + 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, + 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 526, + 1, 526, 1, 526, 1, 526, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, + 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, + 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, + 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, + 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 528, 1, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 1, 529, 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, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, 1, 530, + 1, 530, 1, 530, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, + 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, + 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, + 1, 531, 1, 531, 1, 531, 1, 531, 1, 531, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 533, 1, 533, 1, 533, + 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, + 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, + 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 534, 1, 534, 1, 534, + 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, + 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 534, 1, 535, 1, 535, + 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, + 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, + 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, 1, 535, + 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, + 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, + 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, 537, + 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 538, 1, 538, 1, 538, + 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 538, 1, 539, 1, 539, 1, 539, + 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 540, 1, 540, 1, 540, 1, 540, + 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, + 1, 541, 1, 541, 1, 541, 1, 542, 1, 542, 1, 542, 1, 542, 1, 543, 1, 543, + 1, 543, 1, 543, 1, 543, 1, 543, 1, 543, 1, 544, 1, 544, 1, 544, 1, 544, + 1, 544, 1, 544, 1, 544, 1, 544, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, + 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, + 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, 1, 546, + 1, 546, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 548, + 1, 548, 1, 548, 1, 548, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, + 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 549, 1, 550, 1, 550, 1, 550, + 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, + 1, 550, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, 1, 552, + 1, 553, 1, 553, 1, 553, 1, 553, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, + 1, 554, 1, 554, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 556, 1, 556, + 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 557, 1, 557, + 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, + 1, 558, 1, 558, 1, 558, 1, 558, 1, 558, 1, 559, 1, 559, 1, 559, 1, 559, + 1, 559, 1, 559, 1, 559, 1, 559, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, + 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 560, 1, 561, 1, 561, 1, 561, + 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, + 1, 561, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 563, + 1, 563, 1, 563, 1, 564, 1, 564, 1, 564, 1, 564, 1, 565, 1, 565, 1, 565, + 1, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, 1, 566, + 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, + 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, 568, + 1, 568, 1, 568, 1, 568, 1, 568, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, + 1, 569, 1, 569, 1, 569, 1, 569, 1, 570, 1, 570, 1, 570, 1, 570, 1, 570, + 1, 570, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 572, 1, 572, 1, 572, + 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 573, 1, 573, 1, 573, + 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 574, 1, 574, + 1, 574, 1, 574, 1, 574, 1, 574, 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, + 1, 575, 1, 575, 1, 575, 1, 575, 1, 575, 1, 576, 1, 576, 1, 576, 1, 576, + 1, 576, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, 1, 577, + 1, 577, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, + 1, 578, 1, 578, 1, 578, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, + 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 580, 1, 580, 1, 580, 1, 580, + 1, 580, 1, 580, 1, 580, 1, 580, 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, + 1, 581, 1, 581, 1, 581, 1, 581, 1, 581, 1, 582, 1, 582, 1, 582, 1, 582, + 1, 582, 1, 582, 1, 582, 1, 582, 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, + 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 1, 584, 1, 584, 1, 584, 1, 584, + 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 584, 1, 585, 1, 585, + 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, 1, 585, + 1, 585, 1, 585, 1, 585, 1, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, + 1, 586, 1, 586, 1, 586, 1, 586, 1, 587, 1, 587, 1, 587, 1, 587, 1, 587, + 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 589, 1, 589, 1, 589, 1, 589, + 1, 589, 1, 589, 1, 589, 1, 589, 1, 590, 1, 590, 1, 590, 1, 590, 1, 591, + 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 592, 1, 592, + 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, + 1, 592, 1, 592, 1, 592, 1, 592, 1, 592, 1, 593, 1, 593, 1, 593, 1, 593, + 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, 1, 593, + 1, 593, 1, 593, 1, 593, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, + 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 594, 1, 595, 1, 595, + 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, + 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, 1, 595, + 1, 595, 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, + 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, 1, 596, + 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, 1, 597, + 1, 597, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, + 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, + 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 599, 1, 599, 1, 599, + 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, + 1, 599, 1, 599, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 601, 1, 601, + 1, 601, 1, 601, 1, 601, 1, 601, 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, 603, + 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 604, 1, 604, 1, 604, 1, 604, + 1, 604, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, 1, 605, + 1, 605, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, + 1, 606, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 607, 1, 608, + 1, 608, 1, 608, 1, 608, 1, 608, 1, 609, 1, 609, 1, 609, 1, 609, 1, 609, + 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, + 1, 610, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, + 1, 611, 1, 611, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, 1, 612, + 1, 612, 1, 612, 1, 612, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, 1, 613, + 1, 613, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, + 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 614, 1, 615, 1, 615, + 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, + 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, + 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 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, 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, 1, 616, 1, 616, 1, 616, 1, 616, 1, 617, 1, 617, + 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, + 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, + 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 1, 618, 1, 618, 1, 618, + 1, 618, 1, 618, 1, 618, 1, 618, 1, 618, 1, 619, 1, 619, 1, 619, 1, 619, + 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, 1, 619, + 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 620, 1, 621, 1, 621, 1, 621, + 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 622, 1, 622, 1, 622, + 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, 1, 622, + 1, 622, 1, 622, 1, 622, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, 1, 623, + 1, 623, 1, 623, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, + 1, 624, 1, 624, 1, 624, 1, 624, 1, 624, 1, 625, 1, 625, 1, 625, 1, 625, + 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 626, 1, 626, + 1, 626, 1, 626, 1, 626, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, 1, 627, + 1, 627, 1, 627, 1, 627, 1, 627, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, + 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 628, 1, 629, 1, 629, 1, 629, + 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, 1, 629, + 1, 629, 1, 629, 1, 629, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, + 1, 630, 1, 630, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, + 1, 631, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, 1, 632, + 1, 632, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, 1, 633, + 1, 633, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, + 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, + 1, 634, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 636, + 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 637, 1, 637, 1, 637, 1, 637, + 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 639, 1, 639, + 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 639, 1, 640, 1, 640, 1, 640, + 1, 640, 1, 640, 1, 640, 1, 640, 1, 640, 1, 641, 1, 641, 1, 641, 1, 641, + 1, 641, 1, 641, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, + 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, + 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, + 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, 1, 642, + 1, 642, 1, 642, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, 1, 643, + 1, 643, 1, 643, 1, 643, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, 1, 644, + 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, + 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, + 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, 1, 645, + 1, 645, 1, 645, 1, 645, 1, 645, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, + 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 648, 1, 648, 1, 648, + 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, 1, 648, + 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 650, 1, 650, 1, 650, 1, 650, + 1, 650, 1, 650, 1, 650, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, 1, 651, + 1, 651, 1, 651, 1, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, + 1, 652, 1, 652, 1, 652, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, 1, 653, + 1, 653, 1, 653, 1, 653, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, 1, 654, + 1, 654, 1, 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, + 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, + 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, + 1, 655, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, 1, 656, + 1, 656, 1, 656, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, + 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, + 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 657, 1, 658, 1, 658, + 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, 1, 658, + 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 659, 1, 660, + 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 661, 1, 661, + 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 661, 1, 662, + 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, 1, 662, + 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, 1, 663, + 1, 663, 1, 663, 1, 663, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, + 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, + 1, 664, 1, 664, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, 1, 665, + 1, 665, 1, 665, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, 1, 666, + 1, 666, 1, 666, 1, 666, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, + 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, 1, 667, + 1, 667, 1, 667, 1, 667, 1, 667, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, + 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 668, 1, 669, 1, 669, 1, 669, + 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, 1, 669, + 1, 669, 1, 669, 1, 669, 1, 669, 1, 670, 1, 670, 1, 670, 1, 670, 1, 670, + 1, 670, 1, 670, 1, 670, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, + 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, + 1, 671, 1, 671, 1, 671, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, + 1, 672, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 673, 1, 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, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, + 1, 675, 1, 675, 1, 675, 1, 675, 1, 676, 1, 676, 1, 676, 1, 676, 1, 676, + 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 678, 1, 678, + 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, + 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, + 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 679, 1, 679, 1, 679, 1, 679, + 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, + 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 680, 1, 680, + 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 681, 1, 681, 1, 681, 1, 681, + 1, 681, 1, 681, 1, 681, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, + 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 683, 1, 683, 1, 683, 1, 683, + 1, 683, 1, 683, 1, 683, 1, 683, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, + 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, + 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, 1, 684, + 1, 684, 1, 684, 1, 684, 1, 684, 1, 685, 1, 685, 1, 685, 1, 685, 1, 685, + 1, 685, 1, 685, 1, 685, 1, 686, 1, 686, 1, 686, 1, 686, 1, 686, 1, 686, + 1, 686, 1, 686, 1, 686, 1, 686, 1, 686, 1, 686, 1, 687, 1, 687, 1, 687, + 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, + 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, 1, 687, + 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, + 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, + 1, 688, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, 1, 689, + 1, 689, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, + 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, + 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, + 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, + 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, 1, 690, + 1, 690, 1, 690, 1, 690, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, + 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, + 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, + 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, + 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, + 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 691, 1, 692, 1, 692, 1, 692, + 1, 692, 1, 692, 1, 692, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, 1, 693, + 1, 693, 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, 695, 1, 695, 1, 695, 1, 695, 1, 695, + 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, 1, 695, + 1, 695, 1, 695, 1, 695, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, + 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, + 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 1, 697, 1, 697, 1, 697, 1, 697, + 1, 697, 1, 697, 1, 697, 1, 697, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, + 1, 698, 1, 698, 1, 698, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, + 1, 699, 1, 699, 1, 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, 701, 1, 701, + 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 702, 1, 702, 1, 702, 1, 702, + 1, 702, 1, 702, 1, 702, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, + 1, 703, 1, 703, 1, 703, 1, 703, 1, 703, 1, 704, 1, 704, 1, 704, 1, 704, + 1, 704, 1, 704, 1, 704, 1, 705, 1, 705, 1, 705, 1, 705, 1, 705, 1, 705, + 1, 705, 1, 705, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, + 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, + 1, 706, 1, 706, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, + 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 708, 1, 708, + 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, + 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 708, 1, 709, + 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 4, 709, + 10708, 8, 709, 11, 709, 12, 709, 10709, 1, 709, 1, 709, 1, 709, 1, 709, + 1, 709, 1, 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, 711, 1, 711, 1, 711, 1, 711, + 1, 711, 1, 711, 1, 711, 1, 711, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, + 1, 712, 1, 712, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, 1, 713, + 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 714, 1, 715, 1, 715, + 1, 715, 1, 715, 1, 715, 1, 715, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, + 1, 716, 1, 717, 1, 717, 1, 717, 1, 717, 1, 717, 1, 718, 1, 718, 1, 718, + 1, 718, 1, 718, 1, 718, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, 1, 719, + 1, 719, 1, 719, 1, 719, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, + 1, 720, 1, 721, 1, 721, 1, 721, 1, 721, 1, 721, 1, 722, 1, 722, 1, 722, + 1, 722, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, 1, 723, + 1, 723, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, 1, 724, + 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 726, + 1, 726, 1, 726, 1, 726, 1, 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, 728, 1, 728, 1, 728, 1, 728, + 1, 728, 1, 728, 1, 728, 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, 1, 729, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, + 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, 1, 730, + 1, 730, 1, 730, 1, 730, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, + 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, 1, 732, + 1, 732, 1, 732, 1, 732, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 734, + 1, 734, 1, 734, 1, 734, 1, 734, 1, 735, 1, 735, 1, 735, 1, 735, 1, 735, + 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 737, + 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, + 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, + 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 1, 738, 1, 738, + 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, + 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 738, 1, 739, 1, 739, + 1, 739, 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, 1, 740, 1, 740, + 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, + 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, + 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 740, 1, 741, 1, 741, 1, 741, + 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, + 1, 741, 1, 741, 1, 741, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, + 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, + 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, + 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, 1, 743, + 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, + 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 744, 1, 744, + 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, + 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, 1, 744, + 1, 744, 1, 744, 1, 744, 1, 744, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, + 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, + 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, + 1, 745, 1, 745, 1, 745, 1, 745, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, + 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, + 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, 1, 746, + 1, 746, 1, 746, 1, 746, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, + 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, + 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, + 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, 1, 747, + 1, 747, 1, 747, 1, 747, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, + 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 749, + 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, + 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, 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, 1, 750, 1, 750, 1, 750, 1, 750, + 1, 750, 1, 750, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, 1, 751, + 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, 1, 752, + 1, 752, 1, 752, 1, 752, 1, 752, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, + 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, 1, 753, + 1, 753, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, 1, 754, + 1, 754, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, 1, 755, + 1, 755, 1, 755, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, 1, 756, + 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 757, 1, 758, + 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 759, 1, 759, 1, 759, + 1, 759, 1, 759, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, + 1, 760, 1, 760, 1, 760, 1, 760, 1, 760, 1, 761, 1, 761, 1, 761, 1, 761, + 1, 761, 1, 761, 1, 761, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, 1, 762, + 1, 762, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, 1, 763, + 1, 763, 1, 763, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, + 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 764, 1, 765, + 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, + 1, 765, 1, 765, 1, 765, 1, 765, 1, 765, 1, 766, 1, 766, 1, 766, 1, 766, + 1, 766, 1, 766, 1, 766, 1, 766, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, + 1, 767, 1, 767, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, + 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, + 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, + 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 771, 1, 771, 1, 771, 1, 771, + 1, 771, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 773, + 1, 773, 1, 773, 1, 773, 1, 773, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, + 1, 774, 1, 774, 1, 774, 1, 774, 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, + 1, 775, 1, 775, 1, 775, 1, 775, 1, 775, 1, 776, 1, 776, 1, 776, 1, 776, + 1, 776, 1, 776, 1, 776, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, 1, 777, + 1, 777, 1, 777, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, + 1, 778, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, + 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, + 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, 1, 779, + 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, + 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 781, 1, 781, 1, 781, + 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, + 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, + 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 781, 1, 782, + 1, 782, 1, 782, 1, 782, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 784, + 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 784, 1, 785, 1, 785, + 1, 785, 1, 785, 1, 785, 1, 785, 1, 786, 1, 786, 1, 786, 1, 786, 1, 786, + 1, 786, 1, 786, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, 1, 787, + 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, + 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, + 1, 788, 1, 789, 1, 789, 1, 789, 1, 789, 1, 789, 1, 790, 1, 790, 1, 790, + 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 790, 1, 791, 1, 791, 1, 791, + 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, 1, 791, + 1, 791, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, + 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 793, 1, 793, 1, 793, + 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, 1, 793, + 1, 793, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, + 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, 1, 794, + 1, 794, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, + 1, 795, 1, 795, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, + 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, + 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, + 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, + 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 798, 1, 798, 1, 798, 1, 798, + 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 799, + 1, 799, 1, 799, 1, 799, 1, 799, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, + 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 800, 1, 801, 1, 801, 1, 801, + 1, 801, 1, 801, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, + 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, 1, 802, + 1, 802, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, + 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, 1, 803, + 1, 803, 1, 803, 1, 803, 1, 803, 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, + 1, 804, 1, 804, 1, 804, 1, 804, 1, 804, 1, 805, 1, 805, 1, 805, 1, 805, + 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 1, 805, 4, 805, + 11849, 8, 805, 11, 805, 12, 805, 11850, 1, 806, 1, 806, 1, 806, 1, 806, + 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 806, 1, 807, + 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 808, 1, 808, 1, 808, 1, 808, + 1, 808, 1, 808, 1, 808, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, + 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 809, + 1, 809, 1, 809, 1, 809, 1, 809, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, + 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 811, 1, 812, + 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 812, 1, 813, 1, 813, 1, 813, + 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, + 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 814, 1, 814, + 1, 814, 1, 814, 1, 814, 1, 814, 1, 815, 1, 815, 1, 815, 1, 815, 1, 815, + 1, 815, 1, 815, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, + 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 816, 1, 817, 1, 817, + 1, 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, + 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 818, 1, 819, 1, 819, 1, 819, + 1, 819, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, + 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 820, 1, 821, 1, 821, + 1, 821, 1, 821, 1, 821, 1, 821, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, + 1, 822, 1, 822, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, + 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, 1, 823, + 1, 823, 1, 823, 1, 823, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, + 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, 1, 824, + 1, 824, 1, 824, 1, 824, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, + 1, 825, 1, 825, 1, 825, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, + 1, 826, 1, 826, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 828, + 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 829, 1, 829, + 1, 829, 1, 829, 1, 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, 1, 830, + 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 830, 1, 831, 1, 831, + 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, + 1, 831, 1, 831, 1, 831, 1, 831, 1, 831, 1, 832, 1, 832, 1, 832, 1, 832, + 1, 832, 1, 832, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, 1, 833, + 1, 833, 1, 833, 1, 833, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, + 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, + 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, + 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, 1, 834, + 1, 834, 1, 834, 1, 834, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, + 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, + 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, + 1, 835, 1, 835, 1, 835, 1, 835, 1, 835, 1, 836, 1, 836, 1, 836, 1, 836, + 1, 836, 1, 836, 1, 836, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, + 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 838, 1, 838, 1, 838, 1, 838, + 1, 838, 1, 838, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, 1, 839, + 1, 839, 1, 839, 1, 839, 1, 839, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, + 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 840, 1, 841, + 1, 841, 1, 841, 1, 841, 1, 841, 1, 841, 1, 841, 1, 842, 1, 842, 1, 842, + 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 843, + 1, 843, 1, 843, 1, 843, 1, 843, 1, 843, 1, 844, 1, 844, 1, 844, 1, 844, + 1, 844, 1, 844, 1, 844, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 846, + 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 847, + 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 848, 1, 848, + 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 848, 1, 849, 1, 849, 1, 849, + 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, + 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, + 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 850, 1, 850, 1, 850, 1, 850, + 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, + 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, 1, 850, + 1, 850, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, + 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, 1, 851, + 1, 851, 1, 851, 1, 851, 1, 851, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, + 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, + 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, 1, 852, + 1, 852, 1, 852, 1, 852, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, + 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, + 1, 853, 1, 853, 1, 853, 1, 853, 1, 853, 1, 854, 1, 854, 1, 854, 1, 854, + 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, 1, 854, + 1, 854, 1, 854, 1, 854, 1, 854, 1, 855, 1, 855, 1, 855, 1, 855, 1, 856, + 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 857, 1, 857, 1, 857, + 1, 857, 1, 857, 1, 857, 1, 857, 1, 857, 1, 858, 1, 858, 1, 858, 1, 858, + 1, 858, 1, 858, 1, 858, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, + 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, 1, 859, + 1, 859, 1, 859, 1, 859, 1, 859, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, + 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 861, 1, 861, 1, 861, + 1, 861, 1, 861, 1, 861, 1, 861, 1, 861, 1, 861, 1, 861, 1, 861, 1, 861, + 1, 861, 1, 861, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, + 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, 1, 862, + 1, 862, 1, 862, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, + 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, 1, 863, + 1, 863, 1, 863, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, + 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, 1, 864, + 1, 864, 1, 864, 1, 864, 1, 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, + 1, 865, 1, 865, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, 1, 866, + 1, 866, 1, 866, 1, 866, 1, 867, 1, 867, 1, 867, 1, 867, 1, 868, 1, 868, + 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 868, 1, 869, + 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 869, 1, 870, 1, 870, + 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 870, 1, 871, + 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, + 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 871, 1, 872, + 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, + 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, + 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, 1, 872, + 1, 872, 1, 872, 1, 872, 1, 872, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, + 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 874, 1, 875, 1, 875, + 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, 1, 875, + 1, 875, 1, 875, 1, 875, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, 1, 876, + 1, 876, 1, 876, 1, 876, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, + 1, 877, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, 1, 878, + 1, 878, 1, 878, 1, 878, 1, 878, 1, 879, 1, 879, 1, 879, 1, 879, 1, 879, + 1, 879, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, + 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 880, 1, 881, + 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, + 1, 881, 1, 881, 1, 881, 1, 881, 1, 881, 1, 882, 1, 882, 1, 882, 1, 882, + 1, 882, 1, 882, 1, 882, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, + 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 883, 1, 884, 1, 884, 1, 884, + 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, + 1, 884, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, + 1, 886, 1, 886, 1, 886, 1, 886, 1, 887, 1, 887, 1, 887, 1, 887, 1, 887, + 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 889, 1, 889, + 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, 1, 889, + 1, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 891, 1, 891, 1, 891, 1, 891, + 1, 891, 1, 891, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, 893, 1, 893, + 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 893, 1, 894, + 1, 894, 1, 894, 1, 894, 1, 894, 1, 894, 1, 895, 1, 895, 1, 895, 1, 895, + 1, 895, 1, 895, 1, 895, 1, 895, 1, 895, 1, 896, 1, 896, 1, 896, 1, 896, + 1, 896, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 1, 898, + 1, 898, 1, 898, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, 1, 899, + 1, 899, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, 1, 900, + 1, 900, 1, 901, 1, 901, 1, 901, 1, 901, 1, 901, 1, 901, 1, 901, 1, 901, + 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 902, 1, 903, 1, 903, 1, 903, + 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 1, 903, 1, 904, 1, 904, + 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, + 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, + 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 904, 1, 905, + 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, + 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 905, 1, 906, 1, 906, + 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, + 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, 1, 906, + 1, 906, 1, 906, 1, 906, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, + 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 907, 1, 908, + 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, + 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, + 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, + 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, + 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 910, 1, 910, 1, 910, 1, 910, + 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, + 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, + 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, 911, 1, 911, 1, 911, + 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, + 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, + 1, 911, 1, 911, 1, 911, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, + 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, + 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 912, 1, 913, + 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, 1, 913, + 1, 913, 1, 913, 1, 913, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, + 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, + 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, 1, 914, + 1, 914, 1, 914, 1, 914, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, + 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 915, 1, 916, 1, 916, + 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, 1, 916, + 1, 916, 1, 916, 1, 916, 1, 917, 1, 917, 1, 917, 1, 917, 1, 917, 1, 917, + 1, 917, 1, 917, 1, 917, 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, + 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, 1, 919, 1, 919, 1, 919, + 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, + 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 919, 1, 920, 1, 920, 1, 920, + 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, + 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 920, 1, 921, 1, 921, + 1, 921, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, 1, 922, + 1, 922, 1, 922, 1, 922, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, 1, 923, + 1, 923, 1, 923, 1, 924, 1, 924, 1, 924, 1, 924, 1, 925, 1, 925, 1, 925, + 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, + 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 925, 1, 926, + 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 927, + 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, + 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 927, 1, 928, 1, 928, 1, 928, + 1, 928, 1, 928, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, + 1, 929, 1, 929, 1, 929, 1, 929, 1, 929, 1, 930, 1, 930, 1, 930, 1, 930, + 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, + 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, + 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, + 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, 1, 931, + 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, + 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, + 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, + 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, 1, 932, + 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, + 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 934, 1, 934, 1, 934, + 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, + 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, + 1, 934, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, 1, 935, + 1, 935, 1, 935, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, + 1, 936, 1, 936, 1, 936, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, 1, 937, + 1, 937, 1, 937, 1, 938, 1, 938, 1, 938, 1, 938, 1, 938, 1, 938, 1, 938, + 1, 938, 1, 938, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 940, 1, 940, + 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, 1, 940, + 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, + 1, 941, 1, 941, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, + 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, 1, 942, + 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 944, 1, 944, 1, 944, 1, 944, + 1, 944, 1, 944, 1, 944, 1, 944, 1, 944, 1, 945, 1, 945, 1, 945, 1, 945, + 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, 1, 945, + 1, 945, 1, 945, 1, 945, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, + 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 946, 1, 947, 1, 947, 1, 947, + 1, 947, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, 1, 948, + 1, 948, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, 1, 949, + 1, 950, 1, 950, 1, 950, 1, 950, 1, 950, 1, 951, 1, 951, 1, 951, 1, 951, + 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, + 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, 1, 951, + 1, 951, 1, 951, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, + 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, + 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 952, 1, 953, 1, 953, 1, 953, + 1, 953, 1, 953, 1, 954, 1, 954, 1, 954, 1, 954, 1, 954, 1, 954, 1, 954, + 1, 954, 1, 954, 1, 954, 1, 954, 1, 954, 1, 954, 1, 955, 1, 955, 1, 955, + 1, 955, 1, 955, 1, 955, 1, 955, 1, 955, 1, 956, 1, 956, 1, 956, 1, 956, + 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 956, 1, 957, 1, 957, 1, 957, + 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, 1, 957, + 1, 957, 1, 958, 1, 958, 1, 958, 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, + 1, 959, 1, 959, 1, 959, 1, 959, 1, 959, 1, 960, 1, 960, 1, 960, 1, 960, + 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 960, 1, 961, 1, 961, 1, 961, + 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, 1, 961, + 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 963, 1, 963, + 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 964, 1, 964, 1, 964, + 1, 964, 1, 964, 1, 964, 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, + 1, 965, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, 1, 966, + 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, + 1, 967, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 969, + 1, 969, 1, 969, 1, 969, 1, 969, 1, 969, 1, 969, 1, 970, 1, 970, 1, 970, + 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 970, 1, 971, 1, 971, + 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 1, 972, 1, 972, 1, 972, + 1, 972, 1, 972, 1, 972, 1, 972, 1, 973, 1, 973, 1, 973, 1, 973, 1, 973, + 1, 973, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, + 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, + 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 974, 1, 975, 1, 975, 1, 975, + 1, 975, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 976, 1, 977, + 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 1, 978, 1, 978, + 1, 978, 1, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, 1, 979, 1, 980, + 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 981, 1, 981, 1, 981, 1, 981, + 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 983, 1, 983, 1, 983, 1, 983, + 1, 983, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, + 1, 984, 1, 984, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 1, 986, + 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, + 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 987, 1, 987, 1, 987, 1, 987, + 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, + 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, + 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, + 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, 1, 987, + 1, 987, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, + 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, 1, 988, + 1, 988, 1, 988, 1, 988, 1, 988, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, + 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 989, 1, 990, + 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, + 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 990, 1, 991, + 1, 991, 1, 991, 1, 991, 1, 991, 1, 991, 1, 992, 1, 992, 1, 992, 1, 992, + 1, 992, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, 1, 993, + 1, 993, 1, 994, 1, 994, 1, 994, 1, 994, 1, 994, 1, 994, 1, 994, 1, 994, + 1, 994, 1, 994, 1, 994, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, + 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, 1, 995, + 1, 995, 1, 996, 1, 996, 1, 996, 1, 996, 1, 996, 1, 996, 1, 996, 1, 996, + 1, 996, 1, 996, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 998, + 1, 998, 1, 998, 1, 998, 1, 998, 1, 998, 1, 998, 1, 999, 1, 999, 1, 999, + 1, 999, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, 1, 1000, + 1, 1000, 1, 1000, 1, 1000, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, + 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, + 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1005, 1, 1005, 1, 1005, + 1, 1005, 1, 1005, 1, 1005, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, + 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, 1, 1006, + 1, 1006, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1007, + 1, 1007, 1, 1007, 1, 1007, 1, 1007, 1, 1008, 1, 1008, 1, 1008, 1, 1008, + 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1009, 1, 1009, 1, 1009, + 1, 1009, 1, 1009, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, + 1, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1011, 1, 1011, 1, 1011, 1, 1011, + 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1011, 1, 1012, + 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, + 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1012, 1, 1013, 1, 1013, + 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1014, 1, 1014, 1, 1014, + 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, + 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, 1, 1014, + 1, 1014, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1015, + 1, 1015, 1, 1015, 1, 1015, 1, 1015, 1, 1016, 1, 1016, 1, 1016, 1, 1016, + 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, + 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1017, 1, 1017, 1, 1017, 1, 1017, + 1, 1017, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1019, + 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1020, 1, 1020, 1, 1020, 1, 1020, + 1, 1020, 1, 1020, 1, 1020, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, + 1, 1021, 1, 1021, 1, 1021, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1022, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1023, 1, 1024, 1, 1024, + 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1024, 1, 1025, + 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1026, 1, 1026, 1, 1026, + 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1027, 1, 1027, 1, 1027, + 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1028, 1, 1028, 1, 1028, + 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1029, 1, 1029, 1, 1029, + 1, 1029, 1, 1029, 1, 1029, 1, 1029, 1, 1030, 1, 1030, 1, 1030, 1, 1030, + 1, 1030, 1, 1030, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1032, 1, 1032, + 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1033, 1, 1033, 1, 1033, 1, 1033, + 1, 1033, 1, 1033, 1, 1033, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, + 1, 1034, 1, 1034, 1, 1034, 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1035, + 1, 1035, 1, 1035, 1, 1035, 1, 1035, 1, 1036, 1, 1036, 1, 1036, 1, 1036, + 1, 1036, 1, 1036, 1, 1036, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, + 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1038, 1, 1039, 1, 1039, + 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1039, 1, 1040, 1, 1040, + 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1040, 1, 1041, 1, 1041, 1, 1041, + 1, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1042, 1, 1042, 1, 1042, 1, 1042, + 1, 1042, 1, 1042, 1, 1042, 1, 1042, 1, 1043, 1, 1043, 1, 1043, 1, 1043, + 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1044, 1, 1044, 1, 1044, 1, 1044, + 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, 1, 1044, + 1, 1044, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1046, 1, 1046, + 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1047, + 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1048, + 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1049, 1, 1049, + 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 1, 1050, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, + 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1052, 1, 1052, 1, 1052, + 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1053, 1, 1053, + 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1053, 1, 1054, 1, 1054, + 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, + 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1055, 1, 1055, 1, 1055, 1, 1055, + 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1056, 1, 1056, 1, 1056, 1, 1056, + 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1056, 1, 1057, 1, 1057, + 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1057, 1, 1058, + 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1059, 1, 1059, 1, 1059, 1, 1059, + 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1060, 1, 1060, 1, 1060, + 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1061, 1, 1061, 1, 1061, 1, 1061, + 1, 1061, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, + 1, 1062, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, + 1, 1063, 1, 1063, 1, 1063, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, + 1, 1064, 1, 1064, 1, 1064, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, + 1, 1065, 1, 1065, 1, 1065, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1066, + 1, 1066, 1, 1066, 1, 1066, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, + 1, 1067, 1, 1068, 4, 1068, 14650, 8, 1068, 11, 1068, 12, 1068, 14651, 1, + 1068, 1, 1068, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 5, 1069, 14661, + 8, 1069, 10, 1069, 12, 1069, 14664, 9, 1069, 1, 1069, 1, 1069, 1, 1069, + 1, 1069, 1, 1069, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 5, 1070, 14675, 8, + 1070, 10, 1070, 12, 1070, 14678, 9, 1070, 1, 1070, 1, 1070, 1, 1071, 1, + 1071, 1, 1071, 1, 1071, 5, 1071, 14686, 8, 1071, 10, 1071, 12, 1071, 14689, + 9, 1071, 1, 1071, 1, 1071, 1, 1072, 1, 1072, 4, 1072, 14695, 8, 1072, 11, + 1072, 12, 1072, 14696, 1, 1072, 1, 1072, 1, 1073, 1, 1073, 1, 1073, 1, + 1074, 1, 1074, 1, 1075, 1, 1075, 5, 1075, 14708, 8, 1075, 10, 1075, 12, + 1075, 14711, 9, 1075, 1, 1076, 1, 1076, 1, 1076, 5, 1076, 14716, 8, 1076, + 10, 1076, 12, 1076, 14719, 9, 1076, 1, 1077, 1, 1077, 1, 1077, 1, 1077, + 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1078, 1, 1078, 1, 1078, 1, 1078, + 1, 1078, 1, 1078, 1, 1078, 1, 1078, 1, 1078, 1, 1079, 1, 1079, 1, 1079, + 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, 1, 1079, + 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, + 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 5, 1081, 14763, 8, + 1081, 10, 1081, 12, 1081, 14766, 9, 1081, 1, 1081, 1, 1081, 1, 1081, 1, + 1082, 1, 1082, 1, 1082, 1, 1082, 5, 1082, 14775, 8, 1082, 10, 1082, 12, + 1082, 14778, 9, 1082, 1, 1082, 1, 1082, 1, 1083, 4, 1083, 14783, 8, 1083, + 11, 1083, 12, 1083, 14784, 1, 1084, 1, 1084, 1, 1085, 1, 1085, 3, 1085, + 14791, 8, 1085, 1, 1085, 1, 1085, 3, 1085, 14795, 8, 1085, 1, 1085, 4, + 1085, 14798, 8, 1085, 11, 1085, 12, 1085, 14799, 1, 1086, 1, 1086, 1, 1086, + 3, 1086, 14805, 8, 1086, 1, 1086, 1, 1086, 1, 1087, 1, 1087, 1, 1087, 1, + 1087, 3, 1087, 14813, 8, 1087, 1, 1087, 3, 1087, 14816, 8, 1087, 1, 1087, + 1, 1087, 1, 1087, 4, 1087, 14821, 8, 1087, 11, 1087, 12, 1087, 14822, 1, + 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 3, 1087, 14830, 8, 1087, 1, 1088, + 1, 1088, 1, 1089, 1, 1089, 1, 1089, 1, 1090, 1, 1090, 1, 1090, 1, 1091, + 1, 1091, 1, 1091, 1, 1092, 1, 1092, 1, 1092, 1, 1093, 1, 1093, 1, 1094, + 1, 1094, 1, 1095, 1, 1095, 1, 1095, 1, 1096, 1, 1096, 1, 1097, 1, 1097, + 1, 1097, 1, 1098, 1, 1098, 1, 1099, 1, 1099, 1, 1099, 1, 1100, 1, 1100, + 1, 1101, 1, 1101, 1, 1102, 1, 1102, 1, 1103, 1, 1103, 1, 1103, 1, 1103, + 1, 1104, 1, 1104, 1, 1105, 1, 1105, 1, 1106, 1, 1106, 1, 1107, 1, 1107, + 1, 1108, 1, 1108, 1, 1109, 1, 1109, 1, 1110, 1, 1110, 1, 1111, 1, 1111, + 1, 1112, 1, 1112, 1, 1113, 1, 1113, 1, 1114, 1, 1114, 1, 1114, 1, 1115, + 1, 1115, 1, 1116, 1, 1116, 1, 1117, 1, 1117, 1, 1118, 1, 1118, 1, 1119, + 1, 1119, 1, 1120, 1, 1120, 1, 1121, 1, 1121, 1, 1122, 4, 1122, 14911, 8, + 1122, 11, 1122, 12, 1122, 14912, 1, 1122, 1, 1122, 4, 1122, 14917, 8, 1122, + 11, 1122, 12, 1122, 14918, 1, 1122, 4, 1122, 14922, 8, 1122, 11, 1122, + 12, 1122, 14923, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 4, 1122, 14930, 8, + 1122, 11, 1122, 12, 1122, 14931, 3, 1122, 14934, 8, 1122, 1, 1123, 1, 1123, + 1, 1124, 1, 1124, 2, 14662, 14764, 0, 1125, 1, 1, 3, 2, 5, 3, 7, 4, 9, + 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, + 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, + 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, + 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, + 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, + 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, + 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, + 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, + 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, + 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, + 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, + 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, + 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 113, + 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237, 119, 239, 120, 241, + 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126, 253, 127, 255, 128, + 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267, 134, 269, 135, 271, + 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141, 283, 142, 285, 143, + 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297, 149, 299, 150, 301, + 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156, 313, 157, 315, 158, + 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327, 164, 329, 165, 331, + 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171, 343, 172, 345, 173, + 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357, 179, 359, 180, 361, + 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186, 373, 187, 375, 188, + 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387, 194, 389, 195, 391, + 196, 393, 197, 395, 198, 397, 199, 399, 200, 401, 201, 403, 202, 405, 203, + 407, 204, 409, 205, 411, 206, 413, 207, 415, 208, 417, 209, 419, 210, 421, + 211, 423, 212, 425, 213, 427, 214, 429, 215, 431, 216, 433, 217, 435, 218, + 437, 219, 439, 220, 441, 221, 443, 222, 445, 223, 447, 224, 449, 225, 451, + 226, 453, 227, 455, 228, 457, 229, 459, 230, 461, 231, 463, 232, 465, 233, + 467, 234, 469, 235, 471, 236, 473, 237, 475, 238, 477, 239, 479, 240, 481, + 241, 483, 242, 485, 243, 487, 244, 489, 245, 491, 246, 493, 247, 495, 248, + 497, 249, 499, 250, 501, 251, 503, 252, 505, 253, 507, 254, 509, 255, 511, + 256, 513, 257, 515, 258, 517, 259, 519, 260, 521, 261, 523, 262, 525, 263, + 527, 264, 529, 265, 531, 266, 533, 267, 535, 268, 537, 269, 539, 270, 541, + 271, 543, 272, 545, 273, 547, 274, 549, 275, 551, 276, 553, 277, 555, 278, + 557, 279, 559, 280, 561, 281, 563, 282, 565, 283, 567, 284, 569, 285, 571, + 286, 573, 287, 575, 288, 577, 289, 579, 290, 581, 291, 583, 292, 585, 293, + 587, 294, 589, 295, 591, 296, 593, 297, 595, 298, 597, 299, 599, 300, 601, + 301, 603, 302, 605, 303, 607, 304, 609, 305, 611, 306, 613, 307, 615, 308, + 617, 309, 619, 310, 621, 311, 623, 312, 625, 313, 627, 314, 629, 315, 631, + 316, 633, 317, 635, 318, 637, 319, 639, 320, 641, 321, 643, 322, 645, 323, + 647, 324, 649, 325, 651, 326, 653, 327, 655, 328, 657, 329, 659, 330, 661, + 331, 663, 332, 665, 333, 667, 334, 669, 335, 671, 336, 673, 337, 675, 338, + 677, 339, 679, 340, 681, 341, 683, 342, 685, 343, 687, 344, 689, 345, 691, + 346, 693, 347, 695, 348, 697, 349, 699, 350, 701, 351, 703, 352, 705, 353, + 707, 354, 709, 355, 711, 356, 713, 357, 715, 358, 717, 359, 719, 360, 721, + 361, 723, 362, 725, 363, 727, 364, 729, 365, 731, 366, 733, 367, 735, 368, + 737, 369, 739, 370, 741, 371, 743, 372, 745, 373, 747, 374, 749, 375, 751, + 376, 753, 377, 755, 378, 757, 379, 759, 380, 761, 381, 763, 382, 765, 383, + 767, 384, 769, 385, 771, 386, 773, 387, 775, 388, 777, 389, 779, 390, 781, + 391, 783, 392, 785, 393, 787, 394, 789, 395, 791, 396, 793, 397, 795, 398, + 797, 399, 799, 400, 801, 401, 803, 402, 805, 403, 807, 404, 809, 405, 811, + 406, 813, 407, 815, 408, 817, 409, 819, 410, 821, 411, 823, 412, 825, 413, + 827, 414, 829, 415, 831, 416, 833, 417, 835, 418, 837, 419, 839, 420, 841, + 421, 843, 422, 845, 423, 847, 424, 849, 425, 851, 426, 853, 427, 855, 428, + 857, 429, 859, 430, 861, 431, 863, 432, 865, 433, 867, 434, 869, 435, 871, + 436, 873, 437, 875, 438, 877, 439, 879, 440, 881, 441, 883, 442, 885, 443, + 887, 444, 889, 445, 891, 446, 893, 447, 895, 448, 897, 449, 899, 450, 901, + 451, 903, 452, 905, 453, 907, 454, 909, 455, 911, 456, 913, 457, 915, 458, + 917, 459, 919, 460, 921, 461, 923, 462, 925, 463, 927, 464, 929, 465, 931, + 466, 933, 467, 935, 468, 937, 469, 939, 470, 941, 471, 943, 472, 945, 473, + 947, 474, 949, 475, 951, 476, 953, 477, 955, 478, 957, 479, 959, 480, 961, + 481, 963, 482, 965, 483, 967, 484, 969, 485, 971, 486, 973, 487, 975, 488, + 977, 489, 979, 490, 981, 491, 983, 492, 985, 493, 987, 494, 989, 495, 991, + 496, 993, 497, 995, 498, 997, 499, 999, 500, 1001, 501, 1003, 502, 1005, + 503, 1007, 504, 1009, 505, 1011, 506, 1013, 507, 1015, 508, 1017, 509, + 1019, 510, 1021, 511, 1023, 512, 1025, 513, 1027, 514, 1029, 515, 1031, + 516, 1033, 517, 1035, 518, 1037, 519, 1039, 520, 1041, 521, 1043, 522, + 1045, 523, 1047, 524, 1049, 525, 1051, 526, 1053, 527, 1055, 528, 1057, + 529, 1059, 530, 1061, 531, 1063, 532, 1065, 533, 1067, 534, 1069, 535, + 1071, 536, 1073, 537, 1075, 538, 1077, 539, 1079, 540, 1081, 541, 1083, + 542, 1085, 543, 1087, 544, 1089, 545, 1091, 546, 1093, 547, 1095, 548, + 1097, 549, 1099, 550, 1101, 551, 1103, 552, 1105, 553, 1107, 554, 1109, + 555, 1111, 556, 1113, 557, 1115, 558, 1117, 559, 1119, 560, 1121, 561, + 1123, 562, 1125, 563, 1127, 564, 1129, 565, 1131, 566, 1133, 567, 1135, + 568, 1137, 569, 1139, 570, 1141, 571, 1143, 572, 1145, 573, 1147, 574, + 1149, 575, 1151, 576, 1153, 577, 1155, 578, 1157, 579, 1159, 580, 1161, + 581, 1163, 582, 1165, 583, 1167, 584, 1169, 585, 1171, 586, 1173, 587, + 1175, 588, 1177, 589, 1179, 590, 1181, 591, 1183, 592, 1185, 593, 1187, + 594, 1189, 595, 1191, 596, 1193, 597, 1195, 598, 1197, 599, 1199, 600, + 1201, 601, 1203, 602, 1205, 603, 1207, 604, 1209, 605, 1211, 606, 1213, + 607, 1215, 608, 1217, 609, 1219, 610, 1221, 611, 1223, 612, 1225, 613, + 1227, 614, 1229, 615, 1231, 616, 1233, 617, 1235, 618, 1237, 619, 1239, + 620, 1241, 621, 1243, 622, 1245, 623, 1247, 624, 1249, 625, 1251, 626, + 1253, 627, 1255, 628, 1257, 629, 1259, 630, 1261, 631, 1263, 632, 1265, + 633, 1267, 634, 1269, 635, 1271, 636, 1273, 637, 1275, 638, 1277, 639, + 1279, 640, 1281, 641, 1283, 642, 1285, 643, 1287, 644, 1289, 645, 1291, + 646, 1293, 647, 1295, 648, 1297, 649, 1299, 650, 1301, 651, 1303, 652, + 1305, 653, 1307, 654, 1309, 655, 1311, 656, 1313, 657, 1315, 658, 1317, + 659, 1319, 660, 1321, 661, 1323, 662, 1325, 663, 1327, 664, 1329, 665, + 1331, 666, 1333, 667, 1335, 668, 1337, 669, 1339, 670, 1341, 671, 1343, + 672, 1345, 673, 1347, 674, 1349, 675, 1351, 676, 1353, 677, 1355, 678, + 1357, 679, 1359, 680, 1361, 681, 1363, 682, 1365, 683, 1367, 684, 1369, + 685, 1371, 686, 1373, 687, 1375, 688, 1377, 689, 1379, 690, 1381, 691, + 1383, 692, 1385, 693, 1387, 694, 1389, 695, 1391, 696, 1393, 697, 1395, + 698, 1397, 699, 1399, 700, 1401, 701, 1403, 702, 1405, 703, 1407, 704, + 1409, 705, 1411, 706, 1413, 707, 1415, 708, 1417, 709, 1419, 710, 1421, + 711, 1423, 712, 1425, 713, 1427, 714, 1429, 715, 1431, 716, 1433, 717, + 1435, 718, 1437, 719, 1439, 720, 1441, 721, 1443, 722, 1445, 723, 1447, + 724, 1449, 725, 1451, 726, 1453, 727, 1455, 728, 1457, 729, 1459, 730, + 1461, 731, 1463, 732, 1465, 733, 1467, 734, 1469, 735, 1471, 736, 1473, + 737, 1475, 738, 1477, 739, 1479, 740, 1481, 741, 1483, 742, 1485, 743, + 1487, 744, 1489, 745, 1491, 746, 1493, 747, 1495, 748, 1497, 749, 1499, + 750, 1501, 751, 1503, 752, 1505, 753, 1507, 754, 1509, 755, 1511, 756, + 1513, 757, 1515, 758, 1517, 759, 1519, 760, 1521, 761, 1523, 762, 1525, + 763, 1527, 764, 1529, 765, 1531, 766, 1533, 767, 1535, 768, 1537, 769, + 1539, 770, 1541, 771, 1543, 772, 1545, 773, 1547, 774, 1549, 775, 1551, + 776, 1553, 777, 1555, 778, 1557, 779, 1559, 780, 1561, 781, 1563, 782, + 1565, 783, 1567, 784, 1569, 785, 1571, 786, 1573, 787, 1575, 788, 1577, + 789, 1579, 790, 1581, 791, 1583, 792, 1585, 793, 1587, 794, 1589, 795, + 1591, 796, 1593, 797, 1595, 798, 1597, 799, 1599, 800, 1601, 801, 1603, + 802, 1605, 803, 1607, 804, 1609, 805, 1611, 806, 1613, 807, 1615, 808, + 1617, 809, 1619, 810, 1621, 811, 1623, 812, 1625, 813, 1627, 814, 1629, + 815, 1631, 816, 1633, 817, 1635, 818, 1637, 819, 1639, 820, 1641, 821, + 1643, 822, 1645, 823, 1647, 824, 1649, 825, 1651, 826, 1653, 827, 1655, + 828, 1657, 829, 1659, 830, 1661, 831, 1663, 832, 1665, 833, 1667, 834, + 1669, 835, 1671, 836, 1673, 837, 1675, 838, 1677, 839, 1679, 840, 1681, + 841, 1683, 842, 1685, 843, 1687, 844, 1689, 845, 1691, 846, 1693, 847, + 1695, 848, 1697, 849, 1699, 850, 1701, 851, 1703, 852, 1705, 853, 1707, + 854, 1709, 855, 1711, 856, 1713, 857, 1715, 858, 1717, 859, 1719, 860, + 1721, 861, 1723, 862, 1725, 863, 1727, 864, 1729, 865, 1731, 866, 1733, + 867, 1735, 868, 1737, 869, 1739, 870, 1741, 871, 1743, 872, 1745, 873, + 1747, 874, 1749, 875, 1751, 876, 1753, 877, 1755, 878, 1757, 879, 1759, + 880, 1761, 881, 1763, 882, 1765, 883, 1767, 884, 1769, 885, 1771, 886, + 1773, 887, 1775, 888, 1777, 889, 1779, 890, 1781, 891, 1783, 892, 1785, + 893, 1787, 894, 1789, 895, 1791, 896, 1793, 897, 1795, 898, 1797, 899, + 1799, 900, 1801, 901, 1803, 902, 1805, 903, 1807, 904, 1809, 905, 1811, + 906, 1813, 907, 1815, 908, 1817, 909, 1819, 910, 1821, 911, 1823, 912, + 1825, 913, 1827, 914, 1829, 915, 1831, 916, 1833, 917, 1835, 918, 1837, + 919, 1839, 920, 1841, 921, 1843, 922, 1845, 923, 1847, 924, 1849, 925, + 1851, 926, 1853, 927, 1855, 928, 1857, 929, 1859, 930, 1861, 931, 1863, + 932, 1865, 933, 1867, 934, 1869, 935, 1871, 936, 1873, 937, 1875, 938, + 1877, 939, 1879, 940, 1881, 941, 1883, 942, 1885, 943, 1887, 944, 1889, + 945, 1891, 946, 1893, 947, 1895, 948, 1897, 949, 1899, 950, 1901, 951, + 1903, 952, 1905, 953, 1907, 954, 1909, 955, 1911, 956, 1913, 957, 1915, + 958, 1917, 959, 1919, 960, 1921, 961, 1923, 962, 1925, 963, 1927, 964, + 1929, 965, 1931, 966, 1933, 967, 1935, 968, 1937, 969, 1939, 970, 1941, + 971, 1943, 972, 1945, 973, 1947, 974, 1949, 975, 1951, 976, 1953, 977, + 1955, 978, 1957, 979, 1959, 980, 1961, 981, 1963, 982, 1965, 983, 1967, + 984, 1969, 985, 1971, 986, 1973, 987, 1975, 988, 1977, 989, 1979, 990, + 1981, 991, 1983, 992, 1985, 993, 1987, 994, 1989, 995, 1991, 996, 1993, + 997, 1995, 998, 1997, 999, 1999, 1000, 2001, 1001, 2003, 1002, 2005, 1003, + 2007, 1004, 2009, 1005, 2011, 1006, 2013, 1007, 2015, 1008, 2017, 1009, + 2019, 1010, 2021, 1011, 2023, 1012, 2025, 1013, 2027, 1014, 2029, 1015, + 2031, 1016, 2033, 1017, 2035, 1018, 2037, 1019, 2039, 1020, 2041, 1021, + 2043, 1022, 2045, 1023, 2047, 1024, 2049, 1025, 2051, 1026, 2053, 1027, + 2055, 1028, 2057, 1029, 2059, 1030, 2061, 1031, 2063, 1032, 2065, 1033, + 2067, 1034, 2069, 1035, 2071, 1036, 2073, 1037, 2075, 1038, 2077, 1039, + 2079, 1040, 2081, 1041, 2083, 1042, 2085, 1043, 2087, 1044, 2089, 1045, + 2091, 1046, 2093, 1047, 2095, 1048, 2097, 1049, 2099, 1050, 2101, 1051, + 2103, 1052, 2105, 1053, 2107, 1054, 2109, 1055, 2111, 1056, 2113, 1057, + 2115, 1058, 2117, 1059, 2119, 1060, 2121, 1061, 2123, 1062, 2125, 1063, + 2127, 1064, 2129, 1065, 2131, 1066, 2133, 1067, 2135, 1068, 2137, 1069, + 2139, 1070, 2141, 1071, 2143, 1072, 2145, 1073, 2147, 1074, 2149, 1075, + 2151, 1076, 2153, 1077, 2155, 1078, 2157, 1079, 2159, 1080, 2161, 1081, + 2163, 1082, 2165, 1083, 2167, 1084, 2169, 1085, 2171, 1086, 2173, 1087, + 2175, 0, 2177, 0, 2179, 1088, 2181, 1089, 2183, 1090, 2185, 1091, 2187, + 1092, 2189, 1093, 2191, 1094, 2193, 1095, 2195, 1096, 2197, 1097, 2199, + 1098, 2201, 1099, 2203, 1100, 2205, 1101, 2207, 1102, 2209, 1103, 2211, + 1104, 2213, 1105, 2215, 1106, 2217, 1107, 2219, 1108, 2221, 1109, 2223, + 1110, 2225, 1111, 2227, 1112, 2229, 1113, 2231, 1114, 2233, 1115, 2235, + 1116, 2237, 1117, 2239, 1118, 2241, 1119, 2243, 0, 2245, 0, 2247, 0, 2249, + 0, 1, 0, 42, 2, 0, 65, 65, 97, 97, 2, 0, 68, 68, 100, 100, 2, 0, 80, 80, + 112, 112, 2, 0, 82, 82, 114, 114, 2, 0, 79, 79, 111, 111, 2, 0, 86, 86, + 118, 118, 2, 0, 73, 73, 105, 105, 2, 0, 83, 83, 115, 115, 2, 0, 78, 78, + 110, 110, 2, 0, 69, 69, 101, 101, 2, 0, 66, 66, 98, 98, 2, 0, 84, 84, 116, + 116, 2, 0, 70, 70, 102, 102, 2, 0, 87, 87, 119, 119, 2, 0, 67, 67, 99, + 99, 2, 0, 72, 72, 104, 104, 2, 0, 81, 81, 113, 113, 2, 0, 85, 85, 117, + 117, 2, 0, 89, 89, 121, 121, 2, 0, 77, 77, 109, 109, 2, 0, 76, 76, 108, + 108, 2, 0, 71, 71, 103, 103, 2, 0, 75, 75, 107, 107, 2, 0, 88, 88, 120, + 120, 2, 0, 90, 90, 122, 122, 2, 0, 74, 74, 106, 106, 3, 0, 9, 10, 13, 13, + 32, 32, 2, 0, 10, 10, 13, 13, 1, 0, 34, 34, 3, 0, 65, 90, 95, 95, 97, 122, + 5, 0, 36, 36, 48, 57, 64, 90, 95, 95, 97, 122, 4, 0, 48, 57, 65, 90, 95, + 95, 97, 122, 1, 0, 36, 36, 1, 0, 39, 39, 2, 0, 43, 43, 45, 45, 4, 0, 10, + 10, 13, 13, 39, 39, 92, 92, 13, 0, 34, 34, 39, 39, 66, 66, 70, 70, 78, + 78, 82, 82, 84, 84, 92, 92, 98, 98, 102, 102, 110, 110, 114, 114, 116, + 116, 1, 0, 48, 51, 1, 0, 48, 55, 3, 0, 48, 57, 65, 70, 97, 102, 1, 0, 48, + 57, 10, 0, 192, 214, 216, 246, 248, 8191, 11264, 12287, 12352, 12687, 13056, + 13183, 13312, 16383, 19968, 55295, 63744, 64255, 65280, 65520, 14963, 0, + 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, + 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, + 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, + 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, + 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, + 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, + 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, + 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, + 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, + 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, + 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, + 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, + 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, + 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, + 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, + 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, + 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, + 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, + 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, + 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, + 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, + 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, + 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, + 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, + 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, + 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, + 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, + 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, + 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, + 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, + 1, 0, 0, 0, 0, 225, 1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, + 0, 231, 1, 0, 0, 0, 0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, + 0, 0, 0, 0, 239, 1, 0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, + 245, 1, 0, 0, 0, 0, 247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, + 0, 0, 0, 253, 1, 0, 0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, + 1, 0, 0, 0, 0, 261, 1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, + 0, 267, 1, 0, 0, 0, 0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, + 0, 0, 0, 0, 275, 1, 0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, + 281, 1, 0, 0, 0, 0, 283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, + 0, 0, 0, 289, 1, 0, 0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, + 1, 0, 0, 0, 0, 297, 1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, + 0, 303, 1, 0, 0, 0, 0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, + 0, 0, 0, 0, 311, 1, 0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, + 317, 1, 0, 0, 0, 0, 319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, + 0, 0, 0, 325, 1, 0, 0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, + 1, 0, 0, 0, 0, 333, 1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, + 0, 339, 1, 0, 0, 0, 0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, + 0, 0, 0, 0, 347, 1, 0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, + 353, 1, 0, 0, 0, 0, 355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, + 0, 0, 0, 361, 1, 0, 0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, + 1, 0, 0, 0, 0, 369, 1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, + 0, 375, 1, 0, 0, 0, 0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, + 0, 0, 0, 0, 383, 1, 0, 0, 0, 0, 385, 1, 0, 0, 0, 0, 387, 1, 0, 0, 0, 0, + 389, 1, 0, 0, 0, 0, 391, 1, 0, 0, 0, 0, 393, 1, 0, 0, 0, 0, 395, 1, 0, + 0, 0, 0, 397, 1, 0, 0, 0, 0, 399, 1, 0, 0, 0, 0, 401, 1, 0, 0, 0, 0, 403, + 1, 0, 0, 0, 0, 405, 1, 0, 0, 0, 0, 407, 1, 0, 0, 0, 0, 409, 1, 0, 0, 0, + 0, 411, 1, 0, 0, 0, 0, 413, 1, 0, 0, 0, 0, 415, 1, 0, 0, 0, 0, 417, 1, + 0, 0, 0, 0, 419, 1, 0, 0, 0, 0, 421, 1, 0, 0, 0, 0, 423, 1, 0, 0, 0, 0, + 425, 1, 0, 0, 0, 0, 427, 1, 0, 0, 0, 0, 429, 1, 0, 0, 0, 0, 431, 1, 0, + 0, 0, 0, 433, 1, 0, 0, 0, 0, 435, 1, 0, 0, 0, 0, 437, 1, 0, 0, 0, 0, 439, + 1, 0, 0, 0, 0, 441, 1, 0, 0, 0, 0, 443, 1, 0, 0, 0, 0, 445, 1, 0, 0, 0, + 0, 447, 1, 0, 0, 0, 0, 449, 1, 0, 0, 0, 0, 451, 1, 0, 0, 0, 0, 453, 1, + 0, 0, 0, 0, 455, 1, 0, 0, 0, 0, 457, 1, 0, 0, 0, 0, 459, 1, 0, 0, 0, 0, + 461, 1, 0, 0, 0, 0, 463, 1, 0, 0, 0, 0, 465, 1, 0, 0, 0, 0, 467, 1, 0, + 0, 0, 0, 469, 1, 0, 0, 0, 0, 471, 1, 0, 0, 0, 0, 473, 1, 0, 0, 0, 0, 475, + 1, 0, 0, 0, 0, 477, 1, 0, 0, 0, 0, 479, 1, 0, 0, 0, 0, 481, 1, 0, 0, 0, + 0, 483, 1, 0, 0, 0, 0, 485, 1, 0, 0, 0, 0, 487, 1, 0, 0, 0, 0, 489, 1, + 0, 0, 0, 0, 491, 1, 0, 0, 0, 0, 493, 1, 0, 0, 0, 0, 495, 1, 0, 0, 0, 0, + 497, 1, 0, 0, 0, 0, 499, 1, 0, 0, 0, 0, 501, 1, 0, 0, 0, 0, 503, 1, 0, + 0, 0, 0, 505, 1, 0, 0, 0, 0, 507, 1, 0, 0, 0, 0, 509, 1, 0, 0, 0, 0, 511, + 1, 0, 0, 0, 0, 513, 1, 0, 0, 0, 0, 515, 1, 0, 0, 0, 0, 517, 1, 0, 0, 0, + 0, 519, 1, 0, 0, 0, 0, 521, 1, 0, 0, 0, 0, 523, 1, 0, 0, 0, 0, 525, 1, + 0, 0, 0, 0, 527, 1, 0, 0, 0, 0, 529, 1, 0, 0, 0, 0, 531, 1, 0, 0, 0, 0, + 533, 1, 0, 0, 0, 0, 535, 1, 0, 0, 0, 0, 537, 1, 0, 0, 0, 0, 539, 1, 0, + 0, 0, 0, 541, 1, 0, 0, 0, 0, 543, 1, 0, 0, 0, 0, 545, 1, 0, 0, 0, 0, 547, + 1, 0, 0, 0, 0, 549, 1, 0, 0, 0, 0, 551, 1, 0, 0, 0, 0, 553, 1, 0, 0, 0, + 0, 555, 1, 0, 0, 0, 0, 557, 1, 0, 0, 0, 0, 559, 1, 0, 0, 0, 0, 561, 1, + 0, 0, 0, 0, 563, 1, 0, 0, 0, 0, 565, 1, 0, 0, 0, 0, 567, 1, 0, 0, 0, 0, + 569, 1, 0, 0, 0, 0, 571, 1, 0, 0, 0, 0, 573, 1, 0, 0, 0, 0, 575, 1, 0, + 0, 0, 0, 577, 1, 0, 0, 0, 0, 579, 1, 0, 0, 0, 0, 581, 1, 0, 0, 0, 0, 583, + 1, 0, 0, 0, 0, 585, 1, 0, 0, 0, 0, 587, 1, 0, 0, 0, 0, 589, 1, 0, 0, 0, + 0, 591, 1, 0, 0, 0, 0, 593, 1, 0, 0, 0, 0, 595, 1, 0, 0, 0, 0, 597, 1, + 0, 0, 0, 0, 599, 1, 0, 0, 0, 0, 601, 1, 0, 0, 0, 0, 603, 1, 0, 0, 0, 0, + 605, 1, 0, 0, 0, 0, 607, 1, 0, 0, 0, 0, 609, 1, 0, 0, 0, 0, 611, 1, 0, + 0, 0, 0, 613, 1, 0, 0, 0, 0, 615, 1, 0, 0, 0, 0, 617, 1, 0, 0, 0, 0, 619, + 1, 0, 0, 0, 0, 621, 1, 0, 0, 0, 0, 623, 1, 0, 0, 0, 0, 625, 1, 0, 0, 0, + 0, 627, 1, 0, 0, 0, 0, 629, 1, 0, 0, 0, 0, 631, 1, 0, 0, 0, 0, 633, 1, + 0, 0, 0, 0, 635, 1, 0, 0, 0, 0, 637, 1, 0, 0, 0, 0, 639, 1, 0, 0, 0, 0, + 641, 1, 0, 0, 0, 0, 643, 1, 0, 0, 0, 0, 645, 1, 0, 0, 0, 0, 647, 1, 0, + 0, 0, 0, 649, 1, 0, 0, 0, 0, 651, 1, 0, 0, 0, 0, 653, 1, 0, 0, 0, 0, 655, + 1, 0, 0, 0, 0, 657, 1, 0, 0, 0, 0, 659, 1, 0, 0, 0, 0, 661, 1, 0, 0, 0, + 0, 663, 1, 0, 0, 0, 0, 665, 1, 0, 0, 0, 0, 667, 1, 0, 0, 0, 0, 669, 1, + 0, 0, 0, 0, 671, 1, 0, 0, 0, 0, 673, 1, 0, 0, 0, 0, 675, 1, 0, 0, 0, 0, + 677, 1, 0, 0, 0, 0, 679, 1, 0, 0, 0, 0, 681, 1, 0, 0, 0, 0, 683, 1, 0, + 0, 0, 0, 685, 1, 0, 0, 0, 0, 687, 1, 0, 0, 0, 0, 689, 1, 0, 0, 0, 0, 691, + 1, 0, 0, 0, 0, 693, 1, 0, 0, 0, 0, 695, 1, 0, 0, 0, 0, 697, 1, 0, 0, 0, + 0, 699, 1, 0, 0, 0, 0, 701, 1, 0, 0, 0, 0, 703, 1, 0, 0, 0, 0, 705, 1, + 0, 0, 0, 0, 707, 1, 0, 0, 0, 0, 709, 1, 0, 0, 0, 0, 711, 1, 0, 0, 0, 0, + 713, 1, 0, 0, 0, 0, 715, 1, 0, 0, 0, 0, 717, 1, 0, 0, 0, 0, 719, 1, 0, + 0, 0, 0, 721, 1, 0, 0, 0, 0, 723, 1, 0, 0, 0, 0, 725, 1, 0, 0, 0, 0, 727, + 1, 0, 0, 0, 0, 729, 1, 0, 0, 0, 0, 731, 1, 0, 0, 0, 0, 733, 1, 0, 0, 0, + 0, 735, 1, 0, 0, 0, 0, 737, 1, 0, 0, 0, 0, 739, 1, 0, 0, 0, 0, 741, 1, + 0, 0, 0, 0, 743, 1, 0, 0, 0, 0, 745, 1, 0, 0, 0, 0, 747, 1, 0, 0, 0, 0, + 749, 1, 0, 0, 0, 0, 751, 1, 0, 0, 0, 0, 753, 1, 0, 0, 0, 0, 755, 1, 0, + 0, 0, 0, 757, 1, 0, 0, 0, 0, 759, 1, 0, 0, 0, 0, 761, 1, 0, 0, 0, 0, 763, + 1, 0, 0, 0, 0, 765, 1, 0, 0, 0, 0, 767, 1, 0, 0, 0, 0, 769, 1, 0, 0, 0, + 0, 771, 1, 0, 0, 0, 0, 773, 1, 0, 0, 0, 0, 775, 1, 0, 0, 0, 0, 777, 1, + 0, 0, 0, 0, 779, 1, 0, 0, 0, 0, 781, 1, 0, 0, 0, 0, 783, 1, 0, 0, 0, 0, + 785, 1, 0, 0, 0, 0, 787, 1, 0, 0, 0, 0, 789, 1, 0, 0, 0, 0, 791, 1, 0, + 0, 0, 0, 793, 1, 0, 0, 0, 0, 795, 1, 0, 0, 0, 0, 797, 1, 0, 0, 0, 0, 799, + 1, 0, 0, 0, 0, 801, 1, 0, 0, 0, 0, 803, 1, 0, 0, 0, 0, 805, 1, 0, 0, 0, + 0, 807, 1, 0, 0, 0, 0, 809, 1, 0, 0, 0, 0, 811, 1, 0, 0, 0, 0, 813, 1, + 0, 0, 0, 0, 815, 1, 0, 0, 0, 0, 817, 1, 0, 0, 0, 0, 819, 1, 0, 0, 0, 0, + 821, 1, 0, 0, 0, 0, 823, 1, 0, 0, 0, 0, 825, 1, 0, 0, 0, 0, 827, 1, 0, + 0, 0, 0, 829, 1, 0, 0, 0, 0, 831, 1, 0, 0, 0, 0, 833, 1, 0, 0, 0, 0, 835, + 1, 0, 0, 0, 0, 837, 1, 0, 0, 0, 0, 839, 1, 0, 0, 0, 0, 841, 1, 0, 0, 0, + 0, 843, 1, 0, 0, 0, 0, 845, 1, 0, 0, 0, 0, 847, 1, 0, 0, 0, 0, 849, 1, + 0, 0, 0, 0, 851, 1, 0, 0, 0, 0, 853, 1, 0, 0, 0, 0, 855, 1, 0, 0, 0, 0, + 857, 1, 0, 0, 0, 0, 859, 1, 0, 0, 0, 0, 861, 1, 0, 0, 0, 0, 863, 1, 0, + 0, 0, 0, 865, 1, 0, 0, 0, 0, 867, 1, 0, 0, 0, 0, 869, 1, 0, 0, 0, 0, 871, + 1, 0, 0, 0, 0, 873, 1, 0, 0, 0, 0, 875, 1, 0, 0, 0, 0, 877, 1, 0, 0, 0, + 0, 879, 1, 0, 0, 0, 0, 881, 1, 0, 0, 0, 0, 883, 1, 0, 0, 0, 0, 885, 1, + 0, 0, 0, 0, 887, 1, 0, 0, 0, 0, 889, 1, 0, 0, 0, 0, 891, 1, 0, 0, 0, 0, + 893, 1, 0, 0, 0, 0, 895, 1, 0, 0, 0, 0, 897, 1, 0, 0, 0, 0, 899, 1, 0, + 0, 0, 0, 901, 1, 0, 0, 0, 0, 903, 1, 0, 0, 0, 0, 905, 1, 0, 0, 0, 0, 907, + 1, 0, 0, 0, 0, 909, 1, 0, 0, 0, 0, 911, 1, 0, 0, 0, 0, 913, 1, 0, 0, 0, + 0, 915, 1, 0, 0, 0, 0, 917, 1, 0, 0, 0, 0, 919, 1, 0, 0, 0, 0, 921, 1, + 0, 0, 0, 0, 923, 1, 0, 0, 0, 0, 925, 1, 0, 0, 0, 0, 927, 1, 0, 0, 0, 0, + 929, 1, 0, 0, 0, 0, 931, 1, 0, 0, 0, 0, 933, 1, 0, 0, 0, 0, 935, 1, 0, + 0, 0, 0, 937, 1, 0, 0, 0, 0, 939, 1, 0, 0, 0, 0, 941, 1, 0, 0, 0, 0, 943, + 1, 0, 0, 0, 0, 945, 1, 0, 0, 0, 0, 947, 1, 0, 0, 0, 0, 949, 1, 0, 0, 0, + 0, 951, 1, 0, 0, 0, 0, 953, 1, 0, 0, 0, 0, 955, 1, 0, 0, 0, 0, 957, 1, + 0, 0, 0, 0, 959, 1, 0, 0, 0, 0, 961, 1, 0, 0, 0, 0, 963, 1, 0, 0, 0, 0, + 965, 1, 0, 0, 0, 0, 967, 1, 0, 0, 0, 0, 969, 1, 0, 0, 0, 0, 971, 1, 0, + 0, 0, 0, 973, 1, 0, 0, 0, 0, 975, 1, 0, 0, 0, 0, 977, 1, 0, 0, 0, 0, 979, + 1, 0, 0, 0, 0, 981, 1, 0, 0, 0, 0, 983, 1, 0, 0, 0, 0, 985, 1, 0, 0, 0, + 0, 987, 1, 0, 0, 0, 0, 989, 1, 0, 0, 0, 0, 991, 1, 0, 0, 0, 0, 993, 1, + 0, 0, 0, 0, 995, 1, 0, 0, 0, 0, 997, 1, 0, 0, 0, 0, 999, 1, 0, 0, 0, 0, + 1001, 1, 0, 0, 0, 0, 1003, 1, 0, 0, 0, 0, 1005, 1, 0, 0, 0, 0, 1007, 1, + 0, 0, 0, 0, 1009, 1, 0, 0, 0, 0, 1011, 1, 0, 0, 0, 0, 1013, 1, 0, 0, 0, + 0, 1015, 1, 0, 0, 0, 0, 1017, 1, 0, 0, 0, 0, 1019, 1, 0, 0, 0, 0, 1021, + 1, 0, 0, 0, 0, 1023, 1, 0, 0, 0, 0, 1025, 1, 0, 0, 0, 0, 1027, 1, 0, 0, + 0, 0, 1029, 1, 0, 0, 0, 0, 1031, 1, 0, 0, 0, 0, 1033, 1, 0, 0, 0, 0, 1035, + 1, 0, 0, 0, 0, 1037, 1, 0, 0, 0, 0, 1039, 1, 0, 0, 0, 0, 1041, 1, 0, 0, + 0, 0, 1043, 1, 0, 0, 0, 0, 1045, 1, 0, 0, 0, 0, 1047, 1, 0, 0, 0, 0, 1049, + 1, 0, 0, 0, 0, 1051, 1, 0, 0, 0, 0, 1053, 1, 0, 0, 0, 0, 1055, 1, 0, 0, + 0, 0, 1057, 1, 0, 0, 0, 0, 1059, 1, 0, 0, 0, 0, 1061, 1, 0, 0, 0, 0, 1063, + 1, 0, 0, 0, 0, 1065, 1, 0, 0, 0, 0, 1067, 1, 0, 0, 0, 0, 1069, 1, 0, 0, + 0, 0, 1071, 1, 0, 0, 0, 0, 1073, 1, 0, 0, 0, 0, 1075, 1, 0, 0, 0, 0, 1077, + 1, 0, 0, 0, 0, 1079, 1, 0, 0, 0, 0, 1081, 1, 0, 0, 0, 0, 1083, 1, 0, 0, + 0, 0, 1085, 1, 0, 0, 0, 0, 1087, 1, 0, 0, 0, 0, 1089, 1, 0, 0, 0, 0, 1091, + 1, 0, 0, 0, 0, 1093, 1, 0, 0, 0, 0, 1095, 1, 0, 0, 0, 0, 1097, 1, 0, 0, + 0, 0, 1099, 1, 0, 0, 0, 0, 1101, 1, 0, 0, 0, 0, 1103, 1, 0, 0, 0, 0, 1105, + 1, 0, 0, 0, 0, 1107, 1, 0, 0, 0, 0, 1109, 1, 0, 0, 0, 0, 1111, 1, 0, 0, + 0, 0, 1113, 1, 0, 0, 0, 0, 1115, 1, 0, 0, 0, 0, 1117, 1, 0, 0, 0, 0, 1119, + 1, 0, 0, 0, 0, 1121, 1, 0, 0, 0, 0, 1123, 1, 0, 0, 0, 0, 1125, 1, 0, 0, + 0, 0, 1127, 1, 0, 0, 0, 0, 1129, 1, 0, 0, 0, 0, 1131, 1, 0, 0, 0, 0, 1133, + 1, 0, 0, 0, 0, 1135, 1, 0, 0, 0, 0, 1137, 1, 0, 0, 0, 0, 1139, 1, 0, 0, + 0, 0, 1141, 1, 0, 0, 0, 0, 1143, 1, 0, 0, 0, 0, 1145, 1, 0, 0, 0, 0, 1147, + 1, 0, 0, 0, 0, 1149, 1, 0, 0, 0, 0, 1151, 1, 0, 0, 0, 0, 1153, 1, 0, 0, + 0, 0, 1155, 1, 0, 0, 0, 0, 1157, 1, 0, 0, 0, 0, 1159, 1, 0, 0, 0, 0, 1161, + 1, 0, 0, 0, 0, 1163, 1, 0, 0, 0, 0, 1165, 1, 0, 0, 0, 0, 1167, 1, 0, 0, + 0, 0, 1169, 1, 0, 0, 0, 0, 1171, 1, 0, 0, 0, 0, 1173, 1, 0, 0, 0, 0, 1175, + 1, 0, 0, 0, 0, 1177, 1, 0, 0, 0, 0, 1179, 1, 0, 0, 0, 0, 1181, 1, 0, 0, + 0, 0, 1183, 1, 0, 0, 0, 0, 1185, 1, 0, 0, 0, 0, 1187, 1, 0, 0, 0, 0, 1189, + 1, 0, 0, 0, 0, 1191, 1, 0, 0, 0, 0, 1193, 1, 0, 0, 0, 0, 1195, 1, 0, 0, + 0, 0, 1197, 1, 0, 0, 0, 0, 1199, 1, 0, 0, 0, 0, 1201, 1, 0, 0, 0, 0, 1203, + 1, 0, 0, 0, 0, 1205, 1, 0, 0, 0, 0, 1207, 1, 0, 0, 0, 0, 1209, 1, 0, 0, + 0, 0, 1211, 1, 0, 0, 0, 0, 1213, 1, 0, 0, 0, 0, 1215, 1, 0, 0, 0, 0, 1217, + 1, 0, 0, 0, 0, 1219, 1, 0, 0, 0, 0, 1221, 1, 0, 0, 0, 0, 1223, 1, 0, 0, + 0, 0, 1225, 1, 0, 0, 0, 0, 1227, 1, 0, 0, 0, 0, 1229, 1, 0, 0, 0, 0, 1231, + 1, 0, 0, 0, 0, 1233, 1, 0, 0, 0, 0, 1235, 1, 0, 0, 0, 0, 1237, 1, 0, 0, + 0, 0, 1239, 1, 0, 0, 0, 0, 1241, 1, 0, 0, 0, 0, 1243, 1, 0, 0, 0, 0, 1245, + 1, 0, 0, 0, 0, 1247, 1, 0, 0, 0, 0, 1249, 1, 0, 0, 0, 0, 1251, 1, 0, 0, + 0, 0, 1253, 1, 0, 0, 0, 0, 1255, 1, 0, 0, 0, 0, 1257, 1, 0, 0, 0, 0, 1259, + 1, 0, 0, 0, 0, 1261, 1, 0, 0, 0, 0, 1263, 1, 0, 0, 0, 0, 1265, 1, 0, 0, + 0, 0, 1267, 1, 0, 0, 0, 0, 1269, 1, 0, 0, 0, 0, 1271, 1, 0, 0, 0, 0, 1273, + 1, 0, 0, 0, 0, 1275, 1, 0, 0, 0, 0, 1277, 1, 0, 0, 0, 0, 1279, 1, 0, 0, + 0, 0, 1281, 1, 0, 0, 0, 0, 1283, 1, 0, 0, 0, 0, 1285, 1, 0, 0, 0, 0, 1287, + 1, 0, 0, 0, 0, 1289, 1, 0, 0, 0, 0, 1291, 1, 0, 0, 0, 0, 1293, 1, 0, 0, + 0, 0, 1295, 1, 0, 0, 0, 0, 1297, 1, 0, 0, 0, 0, 1299, 1, 0, 0, 0, 0, 1301, + 1, 0, 0, 0, 0, 1303, 1, 0, 0, 0, 0, 1305, 1, 0, 0, 0, 0, 1307, 1, 0, 0, + 0, 0, 1309, 1, 0, 0, 0, 0, 1311, 1, 0, 0, 0, 0, 1313, 1, 0, 0, 0, 0, 1315, + 1, 0, 0, 0, 0, 1317, 1, 0, 0, 0, 0, 1319, 1, 0, 0, 0, 0, 1321, 1, 0, 0, + 0, 0, 1323, 1, 0, 0, 0, 0, 1325, 1, 0, 0, 0, 0, 1327, 1, 0, 0, 0, 0, 1329, + 1, 0, 0, 0, 0, 1331, 1, 0, 0, 0, 0, 1333, 1, 0, 0, 0, 0, 1335, 1, 0, 0, + 0, 0, 1337, 1, 0, 0, 0, 0, 1339, 1, 0, 0, 0, 0, 1341, 1, 0, 0, 0, 0, 1343, + 1, 0, 0, 0, 0, 1345, 1, 0, 0, 0, 0, 1347, 1, 0, 0, 0, 0, 1349, 1, 0, 0, + 0, 0, 1351, 1, 0, 0, 0, 0, 1353, 1, 0, 0, 0, 0, 1355, 1, 0, 0, 0, 0, 1357, + 1, 0, 0, 0, 0, 1359, 1, 0, 0, 0, 0, 1361, 1, 0, 0, 0, 0, 1363, 1, 0, 0, + 0, 0, 1365, 1, 0, 0, 0, 0, 1367, 1, 0, 0, 0, 0, 1369, 1, 0, 0, 0, 0, 1371, + 1, 0, 0, 0, 0, 1373, 1, 0, 0, 0, 0, 1375, 1, 0, 0, 0, 0, 1377, 1, 0, 0, + 0, 0, 1379, 1, 0, 0, 0, 0, 1381, 1, 0, 0, 0, 0, 1383, 1, 0, 0, 0, 0, 1385, + 1, 0, 0, 0, 0, 1387, 1, 0, 0, 0, 0, 1389, 1, 0, 0, 0, 0, 1391, 1, 0, 0, + 0, 0, 1393, 1, 0, 0, 0, 0, 1395, 1, 0, 0, 0, 0, 1397, 1, 0, 0, 0, 0, 1399, + 1, 0, 0, 0, 0, 1401, 1, 0, 0, 0, 0, 1403, 1, 0, 0, 0, 0, 1405, 1, 0, 0, + 0, 0, 1407, 1, 0, 0, 0, 0, 1409, 1, 0, 0, 0, 0, 1411, 1, 0, 0, 0, 0, 1413, + 1, 0, 0, 0, 0, 1415, 1, 0, 0, 0, 0, 1417, 1, 0, 0, 0, 0, 1419, 1, 0, 0, + 0, 0, 1421, 1, 0, 0, 0, 0, 1423, 1, 0, 0, 0, 0, 1425, 1, 0, 0, 0, 0, 1427, + 1, 0, 0, 0, 0, 1429, 1, 0, 0, 0, 0, 1431, 1, 0, 0, 0, 0, 1433, 1, 0, 0, + 0, 0, 1435, 1, 0, 0, 0, 0, 1437, 1, 0, 0, 0, 0, 1439, 1, 0, 0, 0, 0, 1441, + 1, 0, 0, 0, 0, 1443, 1, 0, 0, 0, 0, 1445, 1, 0, 0, 0, 0, 1447, 1, 0, 0, + 0, 0, 1449, 1, 0, 0, 0, 0, 1451, 1, 0, 0, 0, 0, 1453, 1, 0, 0, 0, 0, 1455, + 1, 0, 0, 0, 0, 1457, 1, 0, 0, 0, 0, 1459, 1, 0, 0, 0, 0, 1461, 1, 0, 0, + 0, 0, 1463, 1, 0, 0, 0, 0, 1465, 1, 0, 0, 0, 0, 1467, 1, 0, 0, 0, 0, 1469, + 1, 0, 0, 0, 0, 1471, 1, 0, 0, 0, 0, 1473, 1, 0, 0, 0, 0, 1475, 1, 0, 0, + 0, 0, 1477, 1, 0, 0, 0, 0, 1479, 1, 0, 0, 0, 0, 1481, 1, 0, 0, 0, 0, 1483, + 1, 0, 0, 0, 0, 1485, 1, 0, 0, 0, 0, 1487, 1, 0, 0, 0, 0, 1489, 1, 0, 0, + 0, 0, 1491, 1, 0, 0, 0, 0, 1493, 1, 0, 0, 0, 0, 1495, 1, 0, 0, 0, 0, 1497, + 1, 0, 0, 0, 0, 1499, 1, 0, 0, 0, 0, 1501, 1, 0, 0, 0, 0, 1503, 1, 0, 0, + 0, 0, 1505, 1, 0, 0, 0, 0, 1507, 1, 0, 0, 0, 0, 1509, 1, 0, 0, 0, 0, 1511, + 1, 0, 0, 0, 0, 1513, 1, 0, 0, 0, 0, 1515, 1, 0, 0, 0, 0, 1517, 1, 0, 0, + 0, 0, 1519, 1, 0, 0, 0, 0, 1521, 1, 0, 0, 0, 0, 1523, 1, 0, 0, 0, 0, 1525, + 1, 0, 0, 0, 0, 1527, 1, 0, 0, 0, 0, 1529, 1, 0, 0, 0, 0, 1531, 1, 0, 0, + 0, 0, 1533, 1, 0, 0, 0, 0, 1535, 1, 0, 0, 0, 0, 1537, 1, 0, 0, 0, 0, 1539, + 1, 0, 0, 0, 0, 1541, 1, 0, 0, 0, 0, 1543, 1, 0, 0, 0, 0, 1545, 1, 0, 0, + 0, 0, 1547, 1, 0, 0, 0, 0, 1549, 1, 0, 0, 0, 0, 1551, 1, 0, 0, 0, 0, 1553, + 1, 0, 0, 0, 0, 1555, 1, 0, 0, 0, 0, 1557, 1, 0, 0, 0, 0, 1559, 1, 0, 0, + 0, 0, 1561, 1, 0, 0, 0, 0, 1563, 1, 0, 0, 0, 0, 1565, 1, 0, 0, 0, 0, 1567, + 1, 0, 0, 0, 0, 1569, 1, 0, 0, 0, 0, 1571, 1, 0, 0, 0, 0, 1573, 1, 0, 0, + 0, 0, 1575, 1, 0, 0, 0, 0, 1577, 1, 0, 0, 0, 0, 1579, 1, 0, 0, 0, 0, 1581, + 1, 0, 0, 0, 0, 1583, 1, 0, 0, 0, 0, 1585, 1, 0, 0, 0, 0, 1587, 1, 0, 0, + 0, 0, 1589, 1, 0, 0, 0, 0, 1591, 1, 0, 0, 0, 0, 1593, 1, 0, 0, 0, 0, 1595, + 1, 0, 0, 0, 0, 1597, 1, 0, 0, 0, 0, 1599, 1, 0, 0, 0, 0, 1601, 1, 0, 0, + 0, 0, 1603, 1, 0, 0, 0, 0, 1605, 1, 0, 0, 0, 0, 1607, 1, 0, 0, 0, 0, 1609, + 1, 0, 0, 0, 0, 1611, 1, 0, 0, 0, 0, 1613, 1, 0, 0, 0, 0, 1615, 1, 0, 0, + 0, 0, 1617, 1, 0, 0, 0, 0, 1619, 1, 0, 0, 0, 0, 1621, 1, 0, 0, 0, 0, 1623, + 1, 0, 0, 0, 0, 1625, 1, 0, 0, 0, 0, 1627, 1, 0, 0, 0, 0, 1629, 1, 0, 0, + 0, 0, 1631, 1, 0, 0, 0, 0, 1633, 1, 0, 0, 0, 0, 1635, 1, 0, 0, 0, 0, 1637, + 1, 0, 0, 0, 0, 1639, 1, 0, 0, 0, 0, 1641, 1, 0, 0, 0, 0, 1643, 1, 0, 0, + 0, 0, 1645, 1, 0, 0, 0, 0, 1647, 1, 0, 0, 0, 0, 1649, 1, 0, 0, 0, 0, 1651, + 1, 0, 0, 0, 0, 1653, 1, 0, 0, 0, 0, 1655, 1, 0, 0, 0, 0, 1657, 1, 0, 0, + 0, 0, 1659, 1, 0, 0, 0, 0, 1661, 1, 0, 0, 0, 0, 1663, 1, 0, 0, 0, 0, 1665, + 1, 0, 0, 0, 0, 1667, 1, 0, 0, 0, 0, 1669, 1, 0, 0, 0, 0, 1671, 1, 0, 0, + 0, 0, 1673, 1, 0, 0, 0, 0, 1675, 1, 0, 0, 0, 0, 1677, 1, 0, 0, 0, 0, 1679, + 1, 0, 0, 0, 0, 1681, 1, 0, 0, 0, 0, 1683, 1, 0, 0, 0, 0, 1685, 1, 0, 0, + 0, 0, 1687, 1, 0, 0, 0, 0, 1689, 1, 0, 0, 0, 0, 1691, 1, 0, 0, 0, 0, 1693, + 1, 0, 0, 0, 0, 1695, 1, 0, 0, 0, 0, 1697, 1, 0, 0, 0, 0, 1699, 1, 0, 0, + 0, 0, 1701, 1, 0, 0, 0, 0, 1703, 1, 0, 0, 0, 0, 1705, 1, 0, 0, 0, 0, 1707, + 1, 0, 0, 0, 0, 1709, 1, 0, 0, 0, 0, 1711, 1, 0, 0, 0, 0, 1713, 1, 0, 0, + 0, 0, 1715, 1, 0, 0, 0, 0, 1717, 1, 0, 0, 0, 0, 1719, 1, 0, 0, 0, 0, 1721, + 1, 0, 0, 0, 0, 1723, 1, 0, 0, 0, 0, 1725, 1, 0, 0, 0, 0, 1727, 1, 0, 0, + 0, 0, 1729, 1, 0, 0, 0, 0, 1731, 1, 0, 0, 0, 0, 1733, 1, 0, 0, 0, 0, 1735, + 1, 0, 0, 0, 0, 1737, 1, 0, 0, 0, 0, 1739, 1, 0, 0, 0, 0, 1741, 1, 0, 0, + 0, 0, 1743, 1, 0, 0, 0, 0, 1745, 1, 0, 0, 0, 0, 1747, 1, 0, 0, 0, 0, 1749, + 1, 0, 0, 0, 0, 1751, 1, 0, 0, 0, 0, 1753, 1, 0, 0, 0, 0, 1755, 1, 0, 0, + 0, 0, 1757, 1, 0, 0, 0, 0, 1759, 1, 0, 0, 0, 0, 1761, 1, 0, 0, 0, 0, 1763, + 1, 0, 0, 0, 0, 1765, 1, 0, 0, 0, 0, 1767, 1, 0, 0, 0, 0, 1769, 1, 0, 0, + 0, 0, 1771, 1, 0, 0, 0, 0, 1773, 1, 0, 0, 0, 0, 1775, 1, 0, 0, 0, 0, 1777, + 1, 0, 0, 0, 0, 1779, 1, 0, 0, 0, 0, 1781, 1, 0, 0, 0, 0, 1783, 1, 0, 0, + 0, 0, 1785, 1, 0, 0, 0, 0, 1787, 1, 0, 0, 0, 0, 1789, 1, 0, 0, 0, 0, 1791, + 1, 0, 0, 0, 0, 1793, 1, 0, 0, 0, 0, 1795, 1, 0, 0, 0, 0, 1797, 1, 0, 0, + 0, 0, 1799, 1, 0, 0, 0, 0, 1801, 1, 0, 0, 0, 0, 1803, 1, 0, 0, 0, 0, 1805, + 1, 0, 0, 0, 0, 1807, 1, 0, 0, 0, 0, 1809, 1, 0, 0, 0, 0, 1811, 1, 0, 0, + 0, 0, 1813, 1, 0, 0, 0, 0, 1815, 1, 0, 0, 0, 0, 1817, 1, 0, 0, 0, 0, 1819, + 1, 0, 0, 0, 0, 1821, 1, 0, 0, 0, 0, 1823, 1, 0, 0, 0, 0, 1825, 1, 0, 0, + 0, 0, 1827, 1, 0, 0, 0, 0, 1829, 1, 0, 0, 0, 0, 1831, 1, 0, 0, 0, 0, 1833, + 1, 0, 0, 0, 0, 1835, 1, 0, 0, 0, 0, 1837, 1, 0, 0, 0, 0, 1839, 1, 0, 0, + 0, 0, 1841, 1, 0, 0, 0, 0, 1843, 1, 0, 0, 0, 0, 1845, 1, 0, 0, 0, 0, 1847, + 1, 0, 0, 0, 0, 1849, 1, 0, 0, 0, 0, 1851, 1, 0, 0, 0, 0, 1853, 1, 0, 0, + 0, 0, 1855, 1, 0, 0, 0, 0, 1857, 1, 0, 0, 0, 0, 1859, 1, 0, 0, 0, 0, 1861, + 1, 0, 0, 0, 0, 1863, 1, 0, 0, 0, 0, 1865, 1, 0, 0, 0, 0, 1867, 1, 0, 0, + 0, 0, 1869, 1, 0, 0, 0, 0, 1871, 1, 0, 0, 0, 0, 1873, 1, 0, 0, 0, 0, 1875, + 1, 0, 0, 0, 0, 1877, 1, 0, 0, 0, 0, 1879, 1, 0, 0, 0, 0, 1881, 1, 0, 0, + 0, 0, 1883, 1, 0, 0, 0, 0, 1885, 1, 0, 0, 0, 0, 1887, 1, 0, 0, 0, 0, 1889, + 1, 0, 0, 0, 0, 1891, 1, 0, 0, 0, 0, 1893, 1, 0, 0, 0, 0, 1895, 1, 0, 0, + 0, 0, 1897, 1, 0, 0, 0, 0, 1899, 1, 0, 0, 0, 0, 1901, 1, 0, 0, 0, 0, 1903, + 1, 0, 0, 0, 0, 1905, 1, 0, 0, 0, 0, 1907, 1, 0, 0, 0, 0, 1909, 1, 0, 0, + 0, 0, 1911, 1, 0, 0, 0, 0, 1913, 1, 0, 0, 0, 0, 1915, 1, 0, 0, 0, 0, 1917, + 1, 0, 0, 0, 0, 1919, 1, 0, 0, 0, 0, 1921, 1, 0, 0, 0, 0, 1923, 1, 0, 0, + 0, 0, 1925, 1, 0, 0, 0, 0, 1927, 1, 0, 0, 0, 0, 1929, 1, 0, 0, 0, 0, 1931, + 1, 0, 0, 0, 0, 1933, 1, 0, 0, 0, 0, 1935, 1, 0, 0, 0, 0, 1937, 1, 0, 0, + 0, 0, 1939, 1, 0, 0, 0, 0, 1941, 1, 0, 0, 0, 0, 1943, 1, 0, 0, 0, 0, 1945, + 1, 0, 0, 0, 0, 1947, 1, 0, 0, 0, 0, 1949, 1, 0, 0, 0, 0, 1951, 1, 0, 0, + 0, 0, 1953, 1, 0, 0, 0, 0, 1955, 1, 0, 0, 0, 0, 1957, 1, 0, 0, 0, 0, 1959, + 1, 0, 0, 0, 0, 1961, 1, 0, 0, 0, 0, 1963, 1, 0, 0, 0, 0, 1965, 1, 0, 0, + 0, 0, 1967, 1, 0, 0, 0, 0, 1969, 1, 0, 0, 0, 0, 1971, 1, 0, 0, 0, 0, 1973, + 1, 0, 0, 0, 0, 1975, 1, 0, 0, 0, 0, 1977, 1, 0, 0, 0, 0, 1979, 1, 0, 0, + 0, 0, 1981, 1, 0, 0, 0, 0, 1983, 1, 0, 0, 0, 0, 1985, 1, 0, 0, 0, 0, 1987, + 1, 0, 0, 0, 0, 1989, 1, 0, 0, 0, 0, 1991, 1, 0, 0, 0, 0, 1993, 1, 0, 0, + 0, 0, 1995, 1, 0, 0, 0, 0, 1997, 1, 0, 0, 0, 0, 1999, 1, 0, 0, 0, 0, 2001, + 1, 0, 0, 0, 0, 2003, 1, 0, 0, 0, 0, 2005, 1, 0, 0, 0, 0, 2007, 1, 0, 0, + 0, 0, 2009, 1, 0, 0, 0, 0, 2011, 1, 0, 0, 0, 0, 2013, 1, 0, 0, 0, 0, 2015, + 1, 0, 0, 0, 0, 2017, 1, 0, 0, 0, 0, 2019, 1, 0, 0, 0, 0, 2021, 1, 0, 0, + 0, 0, 2023, 1, 0, 0, 0, 0, 2025, 1, 0, 0, 0, 0, 2027, 1, 0, 0, 0, 0, 2029, + 1, 0, 0, 0, 0, 2031, 1, 0, 0, 0, 0, 2033, 1, 0, 0, 0, 0, 2035, 1, 0, 0, + 0, 0, 2037, 1, 0, 0, 0, 0, 2039, 1, 0, 0, 0, 0, 2041, 1, 0, 0, 0, 0, 2043, + 1, 0, 0, 0, 0, 2045, 1, 0, 0, 0, 0, 2047, 1, 0, 0, 0, 0, 2049, 1, 0, 0, + 0, 0, 2051, 1, 0, 0, 0, 0, 2053, 1, 0, 0, 0, 0, 2055, 1, 0, 0, 0, 0, 2057, + 1, 0, 0, 0, 0, 2059, 1, 0, 0, 0, 0, 2061, 1, 0, 0, 0, 0, 2063, 1, 0, 0, + 0, 0, 2065, 1, 0, 0, 0, 0, 2067, 1, 0, 0, 0, 0, 2069, 1, 0, 0, 0, 0, 2071, + 1, 0, 0, 0, 0, 2073, 1, 0, 0, 0, 0, 2075, 1, 0, 0, 0, 0, 2077, 1, 0, 0, + 0, 0, 2079, 1, 0, 0, 0, 0, 2081, 1, 0, 0, 0, 0, 2083, 1, 0, 0, 0, 0, 2085, + 1, 0, 0, 0, 0, 2087, 1, 0, 0, 0, 0, 2089, 1, 0, 0, 0, 0, 2091, 1, 0, 0, + 0, 0, 2093, 1, 0, 0, 0, 0, 2095, 1, 0, 0, 0, 0, 2097, 1, 0, 0, 0, 0, 2099, + 1, 0, 0, 0, 0, 2101, 1, 0, 0, 0, 0, 2103, 1, 0, 0, 0, 0, 2105, 1, 0, 0, + 0, 0, 2107, 1, 0, 0, 0, 0, 2109, 1, 0, 0, 0, 0, 2111, 1, 0, 0, 0, 0, 2113, + 1, 0, 0, 0, 0, 2115, 1, 0, 0, 0, 0, 2117, 1, 0, 0, 0, 0, 2119, 1, 0, 0, + 0, 0, 2121, 1, 0, 0, 0, 0, 2123, 1, 0, 0, 0, 0, 2125, 1, 0, 0, 0, 0, 2127, + 1, 0, 0, 0, 0, 2129, 1, 0, 0, 0, 0, 2131, 1, 0, 0, 0, 0, 2133, 1, 0, 0, + 0, 0, 2135, 1, 0, 0, 0, 0, 2137, 1, 0, 0, 0, 0, 2139, 1, 0, 0, 0, 0, 2141, + 1, 0, 0, 0, 0, 2143, 1, 0, 0, 0, 0, 2145, 1, 0, 0, 0, 0, 2147, 1, 0, 0, + 0, 0, 2149, 1, 0, 0, 0, 0, 2151, 1, 0, 0, 0, 0, 2153, 1, 0, 0, 0, 0, 2155, + 1, 0, 0, 0, 0, 2157, 1, 0, 0, 0, 0, 2159, 1, 0, 0, 0, 0, 2161, 1, 0, 0, + 0, 0, 2163, 1, 0, 0, 0, 0, 2165, 1, 0, 0, 0, 0, 2167, 1, 0, 0, 0, 0, 2169, + 1, 0, 0, 0, 0, 2171, 1, 0, 0, 0, 0, 2173, 1, 0, 0, 0, 0, 2179, 1, 0, 0, + 0, 0, 2181, 1, 0, 0, 0, 0, 2183, 1, 0, 0, 0, 0, 2185, 1, 0, 0, 0, 0, 2187, + 1, 0, 0, 0, 0, 2189, 1, 0, 0, 0, 0, 2191, 1, 0, 0, 0, 0, 2193, 1, 0, 0, + 0, 0, 2195, 1, 0, 0, 0, 0, 2197, 1, 0, 0, 0, 0, 2199, 1, 0, 0, 0, 0, 2201, + 1, 0, 0, 0, 0, 2203, 1, 0, 0, 0, 0, 2205, 1, 0, 0, 0, 0, 2207, 1, 0, 0, + 0, 0, 2209, 1, 0, 0, 0, 0, 2211, 1, 0, 0, 0, 0, 2213, 1, 0, 0, 0, 0, 2215, + 1, 0, 0, 0, 0, 2217, 1, 0, 0, 0, 0, 2219, 1, 0, 0, 0, 0, 2221, 1, 0, 0, + 0, 0, 2223, 1, 0, 0, 0, 0, 2225, 1, 0, 0, 0, 0, 2227, 1, 0, 0, 0, 0, 2229, + 1, 0, 0, 0, 0, 2231, 1, 0, 0, 0, 0, 2233, 1, 0, 0, 0, 0, 2235, 1, 0, 0, + 0, 0, 2237, 1, 0, 0, 0, 0, 2239, 1, 0, 0, 0, 0, 2241, 1, 0, 0, 0, 1, 2251, + 1, 0, 0, 0, 3, 2269, 1, 0, 0, 0, 5, 2275, 1, 0, 0, 0, 7, 2292, 1, 0, 0, + 0, 9, 2313, 1, 0, 0, 0, 11, 2329, 1, 0, 0, 0, 13, 2336, 1, 0, 0, 0, 15, + 2345, 1, 0, 0, 0, 17, 2352, 1, 0, 0, 0, 19, 2360, 1, 0, 0, 0, 21, 2373, + 1, 0, 0, 0, 23, 2382, 1, 0, 0, 0, 25, 2389, 1, 0, 0, 0, 27, 2396, 1, 0, + 0, 0, 29, 2400, 1, 0, 0, 0, 31, 2411, 1, 0, 0, 0, 33, 2422, 1, 0, 0, 0, + 35, 2437, 1, 0, 0, 0, 37, 2441, 1, 0, 0, 0, 39, 2447, 1, 0, 0, 0, 41, 2457, + 1, 0, 0, 0, 43, 2463, 1, 0, 0, 0, 45, 2470, 1, 0, 0, 0, 47, 2474, 1, 0, + 0, 0, 49, 2482, 1, 0, 0, 0, 51, 2499, 1, 0, 0, 0, 53, 2517, 1, 0, 0, 0, + 55, 2543, 1, 0, 0, 0, 57, 2559, 1, 0, 0, 0, 59, 2574, 1, 0, 0, 0, 61, 2589, + 1, 0, 0, 0, 63, 2614, 1, 0, 0, 0, 65, 2632, 1, 0, 0, 0, 67, 2648, 1, 0, + 0, 0, 69, 2663, 1, 0, 0, 0, 71, 2689, 1, 0, 0, 0, 73, 2717, 1, 0, 0, 0, + 75, 2741, 1, 0, 0, 0, 77, 2747, 1, 0, 0, 0, 79, 2754, 1, 0, 0, 0, 81, 2758, + 1, 0, 0, 0, 83, 2768, 1, 0, 0, 0, 85, 2782, 1, 0, 0, 0, 87, 2786, 1, 0, + 0, 0, 89, 2790, 1, 0, 0, 0, 91, 2811, 1, 0, 0, 0, 93, 2828, 1, 0, 0, 0, + 95, 2849, 1, 0, 0, 0, 97, 2865, 1, 0, 0, 0, 99, 2873, 1, 0, 0, 0, 101, + 2886, 1, 0, 0, 0, 103, 2893, 1, 0, 0, 0, 105, 2905, 1, 0, 0, 0, 107, 2917, + 1, 0, 0, 0, 109, 2923, 1, 0, 0, 0, 111, 2932, 1, 0, 0, 0, 113, 2935, 1, + 0, 0, 0, 115, 2939, 1, 0, 0, 0, 117, 2946, 1, 0, 0, 0, 119, 2949, 1, 0, + 0, 0, 121, 2963, 1, 0, 0, 0, 123, 2978, 1, 0, 0, 0, 125, 2983, 1, 0, 0, + 0, 127, 2990, 1, 0, 0, 0, 129, 3001, 1, 0, 0, 0, 131, 3026, 1, 0, 0, 0, + 133, 3040, 1, 0, 0, 0, 135, 3054, 1, 0, 0, 0, 137, 3066, 1, 0, 0, 0, 139, + 3078, 1, 0, 0, 0, 141, 3091, 1, 0, 0, 0, 143, 3103, 1, 0, 0, 0, 145, 3116, + 1, 0, 0, 0, 147, 3120, 1, 0, 0, 0, 149, 3125, 1, 0, 0, 0, 151, 3132, 1, + 0, 0, 0, 153, 3143, 1, 0, 0, 0, 155, 3152, 1, 0, 0, 0, 157, 3167, 1, 0, + 0, 0, 159, 3175, 1, 0, 0, 0, 161, 3192, 1, 0, 0, 0, 163, 3206, 1, 0, 0, + 0, 165, 3224, 1, 0, 0, 0, 167, 3234, 1, 0, 0, 0, 169, 3240, 1, 0, 0, 0, + 171, 3264, 1, 0, 0, 0, 173, 3281, 1, 0, 0, 0, 175, 3313, 1, 0, 0, 0, 177, + 3321, 1, 0, 0, 0, 179, 3337, 1, 0, 0, 0, 181, 3369, 1, 0, 0, 0, 183, 3385, + 1, 0, 0, 0, 185, 3392, 1, 0, 0, 0, 187, 3399, 1, 0, 0, 0, 189, 3405, 1, + 0, 0, 0, 191, 3415, 1, 0, 0, 0, 193, 3423, 1, 0, 0, 0, 195, 3438, 1, 0, + 0, 0, 197, 3454, 1, 0, 0, 0, 199, 3468, 1, 0, 0, 0, 201, 3488, 1, 0, 0, + 0, 203, 3509, 1, 0, 0, 0, 205, 3517, 1, 0, 0, 0, 207, 3523, 1, 0, 0, 0, + 209, 3539, 1, 0, 0, 0, 211, 3558, 1, 0, 0, 0, 213, 3563, 1, 0, 0, 0, 215, + 3570, 1, 0, 0, 0, 217, 3577, 1, 0, 0, 0, 219, 3595, 1, 0, 0, 0, 221, 3598, + 1, 0, 0, 0, 223, 3602, 1, 0, 0, 0, 225, 3608, 1, 0, 0, 0, 227, 3613, 1, + 0, 0, 0, 229, 3620, 1, 0, 0, 0, 231, 3627, 1, 0, 0, 0, 233, 3635, 1, 0, + 0, 0, 235, 3640, 1, 0, 0, 0, 237, 3657, 1, 0, 0, 0, 239, 3672, 1, 0, 0, + 0, 241, 3677, 1, 0, 0, 0, 243, 3683, 1, 0, 0, 0, 245, 3695, 1, 0, 0, 0, + 247, 3702, 1, 0, 0, 0, 249, 3710, 1, 0, 0, 0, 251, 3722, 1, 0, 0, 0, 253, + 3739, 1, 0, 0, 0, 255, 3755, 1, 0, 0, 0, 257, 3760, 1, 0, 0, 0, 259, 3770, + 1, 0, 0, 0, 261, 3780, 1, 0, 0, 0, 263, 3786, 1, 0, 0, 0, 265, 3795, 1, + 0, 0, 0, 267, 3808, 1, 0, 0, 0, 269, 3825, 1, 0, 0, 0, 271, 3838, 1, 0, + 0, 0, 273, 3858, 1, 0, 0, 0, 275, 3866, 1, 0, 0, 0, 277, 3910, 1, 0, 0, + 0, 279, 3937, 1, 0, 0, 0, 281, 3957, 1, 0, 0, 0, 283, 4000, 1, 0, 0, 0, + 285, 4037, 1, 0, 0, 0, 287, 4061, 1, 0, 0, 0, 289, 4086, 1, 0, 0, 0, 291, + 4124, 1, 0, 0, 0, 293, 4150, 1, 0, 0, 0, 295, 4196, 1, 0, 0, 0, 297, 4226, + 1, 0, 0, 0, 299, 4232, 1, 0, 0, 0, 301, 4238, 1, 0, 0, 0, 303, 4246, 1, + 0, 0, 0, 305, 4256, 1, 0, 0, 0, 307, 4267, 1, 0, 0, 0, 309, 4276, 1, 0, + 0, 0, 311, 4284, 1, 0, 0, 0, 313, 4295, 1, 0, 0, 0, 315, 4302, 1, 0, 0, + 0, 317, 4310, 1, 0, 0, 0, 319, 4321, 1, 0, 0, 0, 321, 4330, 1, 0, 0, 0, + 323, 4338, 1, 0, 0, 0, 325, 4345, 1, 0, 0, 0, 327, 4355, 1, 0, 0, 0, 329, + 4364, 1, 0, 0, 0, 331, 4376, 1, 0, 0, 0, 333, 4383, 1, 0, 0, 0, 335, 4407, + 1, 0, 0, 0, 337, 4417, 1, 0, 0, 0, 339, 4427, 1, 0, 0, 0, 341, 4441, 1, + 0, 0, 0, 343, 4449, 1, 0, 0, 0, 345, 4460, 1, 0, 0, 0, 347, 4472, 1, 0, + 0, 0, 349, 4483, 1, 0, 0, 0, 351, 4495, 1, 0, 0, 0, 353, 4504, 1, 0, 0, + 0, 355, 4512, 1, 0, 0, 0, 357, 4520, 1, 0, 0, 0, 359, 4536, 1, 0, 0, 0, + 361, 4549, 1, 0, 0, 0, 363, 4558, 1, 0, 0, 0, 365, 4566, 1, 0, 0, 0, 367, + 4579, 1, 0, 0, 0, 369, 4586, 1, 0, 0, 0, 371, 4591, 1, 0, 0, 0, 373, 4601, + 1, 0, 0, 0, 375, 4614, 1, 0, 0, 0, 377, 4620, 1, 0, 0, 0, 379, 4630, 1, + 0, 0, 0, 381, 4637, 1, 0, 0, 0, 383, 4649, 1, 0, 0, 0, 385, 4662, 1, 0, + 0, 0, 387, 4668, 1, 0, 0, 0, 389, 4672, 1, 0, 0, 0, 391, 4678, 1, 0, 0, + 0, 393, 4683, 1, 0, 0, 0, 395, 4693, 1, 0, 0, 0, 397, 4701, 1, 0, 0, 0, + 399, 4714, 1, 0, 0, 0, 401, 4727, 1, 0, 0, 0, 403, 4745, 1, 0, 0, 0, 405, + 4758, 1, 0, 0, 0, 407, 4765, 1, 0, 0, 0, 409, 4772, 1, 0, 0, 0, 411, 4778, + 1, 0, 0, 0, 413, 4783, 1, 0, 0, 0, 415, 4792, 1, 0, 0, 0, 417, 4802, 1, + 0, 0, 0, 419, 4830, 1, 0, 0, 0, 421, 4838, 1, 0, 0, 0, 423, 4847, 1, 0, + 0, 0, 425, 4856, 1, 0, 0, 0, 427, 4865, 1, 0, 0, 0, 429, 4877, 1, 0, 0, + 0, 431, 4895, 1, 0, 0, 0, 433, 4914, 1, 0, 0, 0, 435, 4924, 1, 0, 0, 0, + 437, 4929, 1, 0, 0, 0, 439, 4944, 1, 0, 0, 0, 441, 4952, 1, 0, 0, 0, 443, + 4960, 1, 0, 0, 0, 445, 4982, 1, 0, 0, 0, 447, 5000, 1, 0, 0, 0, 449, 5013, + 1, 0, 0, 0, 451, 5031, 1, 0, 0, 0, 453, 5042, 1, 0, 0, 0, 455, 5051, 1, + 0, 0, 0, 457, 5058, 1, 0, 0, 0, 459, 5069, 1, 0, 0, 0, 461, 5077, 1, 0, + 0, 0, 463, 5087, 1, 0, 0, 0, 465, 5094, 1, 0, 0, 0, 467, 5100, 1, 0, 0, + 0, 469, 5111, 1, 0, 0, 0, 471, 5116, 1, 0, 0, 0, 473, 5125, 1, 0, 0, 0, + 475, 5135, 1, 0, 0, 0, 477, 5145, 1, 0, 0, 0, 479, 5153, 1, 0, 0, 0, 481, + 5162, 1, 0, 0, 0, 483, 5183, 1, 0, 0, 0, 485, 5206, 1, 0, 0, 0, 487, 5211, + 1, 0, 0, 0, 489, 5224, 1, 0, 0, 0, 491, 5233, 1, 0, 0, 0, 493, 5236, 1, + 0, 0, 0, 495, 5247, 1, 0, 0, 0, 497, 5254, 1, 0, 0, 0, 499, 5259, 1, 0, + 0, 0, 501, 5267, 1, 0, 0, 0, 503, 5275, 1, 0, 0, 0, 505, 5283, 1, 0, 0, + 0, 507, 5288, 1, 0, 0, 0, 509, 5294, 1, 0, 0, 0, 511, 5300, 1, 0, 0, 0, + 513, 5320, 1, 0, 0, 0, 515, 5327, 1, 0, 0, 0, 517, 5335, 1, 0, 0, 0, 519, + 5356, 1, 0, 0, 0, 521, 5391, 1, 0, 0, 0, 523, 5404, 1, 0, 0, 0, 525, 5430, + 1, 0, 0, 0, 527, 5471, 1, 0, 0, 0, 529, 5480, 1, 0, 0, 0, 531, 5491, 1, + 0, 0, 0, 533, 5495, 1, 0, 0, 0, 535, 5504, 1, 0, 0, 0, 537, 5518, 1, 0, + 0, 0, 539, 5527, 1, 0, 0, 0, 541, 5542, 1, 0, 0, 0, 543, 5565, 1, 0, 0, + 0, 545, 5576, 1, 0, 0, 0, 547, 5585, 1, 0, 0, 0, 549, 5603, 1, 0, 0, 0, + 551, 5634, 1, 0, 0, 0, 553, 5666, 1, 0, 0, 0, 555, 5699, 1, 0, 0, 0, 557, + 5706, 1, 0, 0, 0, 559, 5730, 1, 0, 0, 0, 561, 5737, 1, 0, 0, 0, 563, 5746, + 1, 0, 0, 0, 565, 5756, 1, 0, 0, 0, 567, 5766, 1, 0, 0, 0, 569, 5772, 1, + 0, 0, 0, 571, 5779, 1, 0, 0, 0, 573, 5784, 1, 0, 0, 0, 575, 5791, 1, 0, + 0, 0, 577, 5803, 1, 0, 0, 0, 579, 5811, 1, 0, 0, 0, 581, 5820, 1, 0, 0, + 0, 583, 5829, 1, 0, 0, 0, 585, 5844, 1, 0, 0, 0, 587, 5896, 1, 0, 0, 0, + 589, 5930, 1, 0, 0, 0, 591, 5959, 1, 0, 0, 0, 593, 5988, 1, 0, 0, 0, 595, + 6022, 1, 0, 0, 0, 597, 6044, 1, 0, 0, 0, 599, 6072, 1, 0, 0, 0, 601, 6102, + 1, 0, 0, 0, 603, 6134, 1, 0, 0, 0, 605, 6165, 1, 0, 0, 0, 607, 6213, 1, + 0, 0, 0, 609, 6253, 1, 0, 0, 0, 611, 6273, 1, 0, 0, 0, 613, 6288, 1, 0, + 0, 0, 615, 6297, 1, 0, 0, 0, 617, 6311, 1, 0, 0, 0, 619, 6326, 1, 0, 0, + 0, 621, 6332, 1, 0, 0, 0, 623, 6338, 1, 0, 0, 0, 625, 6354, 1, 0, 0, 0, + 627, 6383, 1, 0, 0, 0, 629, 6388, 1, 0, 0, 0, 631, 6394, 1, 0, 0, 0, 633, + 6409, 1, 0, 0, 0, 635, 6421, 1, 0, 0, 0, 637, 6428, 1, 0, 0, 0, 639, 6434, + 1, 0, 0, 0, 641, 6445, 1, 0, 0, 0, 643, 6453, 1, 0, 0, 0, 645, 6457, 1, + 0, 0, 0, 647, 6463, 1, 0, 0, 0, 649, 6471, 1, 0, 0, 0, 651, 6478, 1, 0, + 0, 0, 653, 6486, 1, 0, 0, 0, 655, 6498, 1, 0, 0, 0, 657, 6508, 1, 0, 0, + 0, 659, 6513, 1, 0, 0, 0, 661, 6518, 1, 0, 0, 0, 663, 6527, 1, 0, 0, 0, + 665, 6537, 1, 0, 0, 0, 667, 6544, 1, 0, 0, 0, 669, 6555, 1, 0, 0, 0, 671, + 6584, 1, 0, 0, 0, 673, 6606, 1, 0, 0, 0, 675, 6610, 1, 0, 0, 0, 677, 6620, + 1, 0, 0, 0, 679, 6647, 1, 0, 0, 0, 681, 6651, 1, 0, 0, 0, 683, 6675, 1, + 0, 0, 0, 685, 6698, 1, 0, 0, 0, 687, 6702, 1, 0, 0, 0, 689, 6737, 1, 0, + 0, 0, 691, 6744, 1, 0, 0, 0, 693, 6760, 1, 0, 0, 0, 695, 6765, 1, 0, 0, + 0, 697, 6771, 1, 0, 0, 0, 699, 6778, 1, 0, 0, 0, 701, 6784, 1, 0, 0, 0, + 703, 6793, 1, 0, 0, 0, 705, 6805, 1, 0, 0, 0, 707, 6812, 1, 0, 0, 0, 709, + 6817, 1, 0, 0, 0, 711, 6824, 1, 0, 0, 0, 713, 6831, 1, 0, 0, 0, 715, 6839, + 1, 0, 0, 0, 717, 6843, 1, 0, 0, 0, 719, 6855, 1, 0, 0, 0, 721, 6860, 1, + 0, 0, 0, 723, 6868, 1, 0, 0, 0, 725, 6874, 1, 0, 0, 0, 727, 6883, 1, 0, + 0, 0, 729, 6886, 1, 0, 0, 0, 731, 6890, 1, 0, 0, 0, 733, 6897, 1, 0, 0, + 0, 735, 6904, 1, 0, 0, 0, 737, 6923, 1, 0, 0, 0, 739, 6938, 1, 0, 0, 0, + 741, 6976, 1, 0, 0, 0, 743, 6992, 1, 0, 0, 0, 745, 7011, 1, 0, 0, 0, 747, + 7017, 1, 0, 0, 0, 749, 7027, 1, 0, 0, 0, 751, 7039, 1, 0, 0, 0, 753, 7049, + 1, 0, 0, 0, 755, 7058, 1, 0, 0, 0, 757, 7065, 1, 0, 0, 0, 759, 7074, 1, + 0, 0, 0, 761, 7077, 1, 0, 0, 0, 763, 7087, 1, 0, 0, 0, 765, 7093, 1, 0, + 0, 0, 767, 7105, 1, 0, 0, 0, 769, 7110, 1, 0, 0, 0, 771, 7120, 1, 0, 0, + 0, 773, 7140, 1, 0, 0, 0, 775, 7177, 1, 0, 0, 0, 777, 7183, 1, 0, 0, 0, + 779, 7189, 1, 0, 0, 0, 781, 7196, 1, 0, 0, 0, 783, 7208, 1, 0, 0, 0, 785, + 7216, 1, 0, 0, 0, 787, 7220, 1, 0, 0, 0, 789, 7232, 1, 0, 0, 0, 791, 7245, + 1, 0, 0, 0, 793, 7255, 1, 0, 0, 0, 795, 7260, 1, 0, 0, 0, 797, 7263, 1, + 0, 0, 0, 799, 7270, 1, 0, 0, 0, 801, 7280, 1, 0, 0, 0, 803, 7290, 1, 0, + 0, 0, 805, 7301, 1, 0, 0, 0, 807, 7327, 1, 0, 0, 0, 809, 7359, 1, 0, 0, + 0, 811, 7385, 1, 0, 0, 0, 813, 7390, 1, 0, 0, 0, 815, 7395, 1, 0, 0, 0, + 817, 7402, 1, 0, 0, 0, 819, 7414, 1, 0, 0, 0, 821, 7441, 1, 0, 0, 0, 823, + 7444, 1, 0, 0, 0, 825, 7449, 1, 0, 0, 0, 827, 7453, 1, 0, 0, 0, 829, 7458, + 1, 0, 0, 0, 831, 7465, 1, 0, 0, 0, 833, 7476, 1, 0, 0, 0, 835, 7480, 1, + 0, 0, 0, 837, 7489, 1, 0, 0, 0, 839, 7495, 1, 0, 0, 0, 841, 7500, 1, 0, + 0, 0, 843, 7510, 1, 0, 0, 0, 845, 7524, 1, 0, 0, 0, 847, 7535, 1, 0, 0, + 0, 849, 7543, 1, 0, 0, 0, 851, 7548, 1, 0, 0, 0, 853, 7553, 1, 0, 0, 0, + 855, 7557, 1, 0, 0, 0, 857, 7564, 1, 0, 0, 0, 859, 7570, 1, 0, 0, 0, 861, + 7575, 1, 0, 0, 0, 863, 7581, 1, 0, 0, 0, 865, 7588, 1, 0, 0, 0, 867, 7593, + 1, 0, 0, 0, 869, 7605, 1, 0, 0, 0, 871, 7619, 1, 0, 0, 0, 873, 7627, 1, + 0, 0, 0, 875, 7632, 1, 0, 0, 0, 877, 7638, 1, 0, 0, 0, 879, 7657, 1, 0, + 0, 0, 881, 7666, 1, 0, 0, 0, 883, 7672, 1, 0, 0, 0, 885, 7685, 1, 0, 0, + 0, 887, 7689, 1, 0, 0, 0, 889, 7695, 1, 0, 0, 0, 891, 7706, 1, 0, 0, 0, + 893, 7713, 1, 0, 0, 0, 895, 7717, 1, 0, 0, 0, 897, 7723, 1, 0, 0, 0, 899, + 7729, 1, 0, 0, 0, 901, 7733, 1, 0, 0, 0, 903, 7740, 1, 0, 0, 0, 905, 7748, + 1, 0, 0, 0, 907, 7753, 1, 0, 0, 0, 909, 7760, 1, 0, 0, 0, 911, 7768, 1, + 0, 0, 0, 913, 7775, 1, 0, 0, 0, 915, 7786, 1, 0, 0, 0, 917, 7792, 1, 0, + 0, 0, 919, 7800, 1, 0, 0, 0, 921, 7808, 1, 0, 0, 0, 923, 7829, 1, 0, 0, + 0, 925, 7845, 1, 0, 0, 0, 927, 7858, 1, 0, 0, 0, 929, 7873, 1, 0, 0, 0, + 931, 7891, 1, 0, 0, 0, 933, 7913, 1, 0, 0, 0, 935, 7945, 1, 0, 0, 0, 937, + 7954, 1, 0, 0, 0, 939, 7963, 1, 0, 0, 0, 941, 7970, 1, 0, 0, 0, 943, 7981, + 1, 0, 0, 0, 945, 7987, 1, 0, 0, 0, 947, 7999, 1, 0, 0, 0, 949, 8003, 1, + 0, 0, 0, 951, 8022, 1, 0, 0, 0, 953, 8037, 1, 0, 0, 0, 955, 8043, 1, 0, + 0, 0, 957, 8051, 1, 0, 0, 0, 959, 8069, 1, 0, 0, 0, 961, 8101, 1, 0, 0, + 0, 963, 8106, 1, 0, 0, 0, 965, 8121, 1, 0, 0, 0, 967, 8128, 1, 0, 0, 0, + 969, 8136, 1, 0, 0, 0, 971, 8145, 1, 0, 0, 0, 973, 8153, 1, 0, 0, 0, 975, + 8158, 1, 0, 0, 0, 977, 8180, 1, 0, 0, 0, 979, 8191, 1, 0, 0, 0, 981, 8203, + 1, 0, 0, 0, 983, 8224, 1, 0, 0, 0, 985, 8229, 1, 0, 0, 0, 987, 8237, 1, + 0, 0, 0, 989, 8243, 1, 0, 0, 0, 991, 8259, 1, 0, 0, 0, 993, 8267, 1, 0, + 0, 0, 995, 8282, 1, 0, 0, 0, 997, 8288, 1, 0, 0, 0, 999, 8294, 1, 0, 0, + 0, 1001, 8302, 1, 0, 0, 0, 1003, 8318, 1, 0, 0, 0, 1005, 8330, 1, 0, 0, + 0, 1007, 8341, 1, 0, 0, 0, 1009, 8354, 1, 0, 0, 0, 1011, 8359, 1, 0, 0, + 0, 1013, 8367, 1, 0, 0, 0, 1015, 8370, 1, 0, 0, 0, 1017, 8375, 1, 0, 0, + 0, 1019, 8382, 1, 0, 0, 0, 1021, 8389, 1, 0, 0, 0, 1023, 8393, 1, 0, 0, + 0, 1025, 8406, 1, 0, 0, 0, 1027, 8420, 1, 0, 0, 0, 1029, 8445, 1, 0, 0, + 0, 1031, 8467, 1, 0, 0, 0, 1033, 8474, 1, 0, 0, 0, 1035, 8487, 1, 0, 0, + 0, 1037, 8498, 1, 0, 0, 0, 1039, 8504, 1, 0, 0, 0, 1041, 8511, 1, 0, 0, + 0, 1043, 8517, 1, 0, 0, 0, 1045, 8522, 1, 0, 0, 0, 1047, 8530, 1, 0, 0, + 0, 1049, 8539, 1, 0, 0, 0, 1051, 8546, 1, 0, 0, 0, 1053, 8565, 1, 0, 0, + 0, 1055, 8569, 1, 0, 0, 0, 1057, 8575, 1, 0, 0, 0, 1059, 8608, 1, 0, 0, + 0, 1061, 8621, 1, 0, 0, 0, 1063, 8649, 1, 0, 0, 0, 1065, 8679, 1, 0, 0, + 0, 1067, 8698, 1, 0, 0, 0, 1069, 8725, 1, 0, 0, 0, 1071, 8744, 1, 0, 0, + 0, 1073, 8773, 1, 0, 0, 0, 1075, 8799, 1, 0, 0, 0, 1077, 8806, 1, 0, 0, + 0, 1079, 8815, 1, 0, 0, 0, 1081, 8823, 1, 0, 0, 0, 1083, 8836, 1, 0, 0, + 0, 1085, 8839, 1, 0, 0, 0, 1087, 8843, 1, 0, 0, 0, 1089, 8850, 1, 0, 0, + 0, 1091, 8858, 1, 0, 0, 0, 1093, 8863, 1, 0, 0, 0, 1095, 8882, 1, 0, 0, + 0, 1097, 8889, 1, 0, 0, 0, 1099, 8893, 1, 0, 0, 0, 1101, 8905, 1, 0, 0, + 0, 1103, 8918, 1, 0, 0, 0, 1105, 8923, 1, 0, 0, 0, 1107, 8926, 1, 0, 0, + 0, 1109, 8930, 1, 0, 0, 0, 1111, 8937, 1, 0, 0, 0, 1113, 8942, 1, 0, 0, + 0, 1115, 8951, 1, 0, 0, 0, 1117, 8962, 1, 0, 0, 0, 1119, 8967, 1, 0, 0, + 0, 1121, 8975, 1, 0, 0, 0, 1123, 8986, 1, 0, 0, 0, 1125, 8999, 1, 0, 0, + 0, 1127, 9006, 1, 0, 0, 0, 1129, 9009, 1, 0, 0, 0, 1131, 9013, 1, 0, 0, + 0, 1133, 9019, 1, 0, 0, 0, 1135, 9025, 1, 0, 0, 0, 1137, 9034, 1, 0, 0, + 0, 1139, 9047, 1, 0, 0, 0, 1141, 9056, 1, 0, 0, 0, 1143, 9062, 1, 0, 0, + 0, 1145, 9067, 1, 0, 0, 0, 1147, 9076, 1, 0, 0, 0, 1149, 9086, 1, 0, 0, + 0, 1151, 9092, 1, 0, 0, 0, 1153, 9102, 1, 0, 0, 0, 1155, 9107, 1, 0, 0, + 0, 1157, 9116, 1, 0, 0, 0, 1159, 9127, 1, 0, 0, 0, 1161, 9138, 1, 0, 0, + 0, 1163, 9146, 1, 0, 0, 0, 1165, 9156, 1, 0, 0, 0, 1167, 9164, 1, 0, 0, + 0, 1169, 9174, 1, 0, 0, 0, 1171, 9185, 1, 0, 0, 0, 1173, 9200, 1, 0, 0, + 0, 1175, 9209, 1, 0, 0, 0, 1177, 9214, 1, 0, 0, 0, 1179, 9219, 1, 0, 0, + 0, 1181, 9227, 1, 0, 0, 0, 1183, 9231, 1, 0, 0, 0, 1185, 9239, 1, 0, 0, + 0, 1187, 9255, 1, 0, 0, 0, 1189, 9271, 1, 0, 0, 0, 1191, 9284, 1, 0, 0, + 0, 1193, 9307, 1, 0, 0, 0, 1195, 9322, 1, 0, 0, 0, 1197, 9332, 1, 0, 0, + 0, 1199, 9355, 1, 0, 0, 0, 1201, 9369, 1, 0, 0, 0, 1203, 9374, 1, 0, 0, + 0, 1205, 9380, 1, 0, 0, 0, 1207, 9402, 1, 0, 0, 0, 1209, 9408, 1, 0, 0, + 0, 1211, 9413, 1, 0, 0, 0, 1213, 9422, 1, 0, 0, 0, 1215, 9431, 1, 0, 0, + 0, 1217, 9438, 1, 0, 0, 0, 1219, 9443, 1, 0, 0, 0, 1221, 9448, 1, 0, 0, + 0, 1223, 9458, 1, 0, 0, 0, 1225, 9468, 1, 0, 0, 0, 1227, 9478, 1, 0, 0, + 0, 1229, 9485, 1, 0, 0, 0, 1231, 9500, 1, 0, 0, 0, 1233, 9529, 1, 0, 0, + 0, 1235, 9563, 1, 0, 0, 0, 1237, 9589, 1, 0, 0, 0, 1239, 9597, 1, 0, 0, + 0, 1241, 9610, 1, 0, 0, 0, 1243, 9616, 1, 0, 0, 0, 1245, 9625, 1, 0, 0, + 0, 1247, 9640, 1, 0, 0, 0, 1249, 9648, 1, 0, 0, 0, 1251, 9660, 1, 0, 0, + 0, 1253, 9671, 1, 0, 0, 0, 1255, 9676, 1, 0, 0, 0, 1257, 9686, 1, 0, 0, + 0, 1259, 9697, 1, 0, 0, 0, 1261, 9712, 1, 0, 0, 0, 1263, 9720, 1, 0, 0, + 0, 1265, 9728, 1, 0, 0, 0, 1267, 9737, 1, 0, 0, 0, 1269, 9746, 1, 0, 0, + 0, 1271, 9764, 1, 0, 0, 0, 1273, 9771, 1, 0, 0, 0, 1275, 9777, 1, 0, 0, + 0, 1277, 9781, 1, 0, 0, 0, 1279, 9788, 1, 0, 0, 0, 1281, 9796, 1, 0, 0, + 0, 1283, 9804, 1, 0, 0, 0, 1285, 9810, 1, 0, 0, 0, 1287, 9846, 1, 0, 0, + 0, 1289, 9856, 1, 0, 0, 0, 1291, 9862, 1, 0, 0, 0, 1293, 9893, 1, 0, 0, + 0, 1295, 9899, 1, 0, 0, 0, 1297, 9904, 1, 0, 0, 0, 1299, 9916, 1, 0, 0, + 0, 1301, 9921, 1, 0, 0, 0, 1303, 9928, 1, 0, 0, 0, 1305, 9937, 1, 0, 0, + 0, 1307, 9946, 1, 0, 0, 0, 1309, 9955, 1, 0, 0, 0, 1311, 9965, 1, 0, 0, + 0, 1313, 9989, 1, 0, 0, 0, 1315, 9999, 1, 0, 0, 0, 1317, 10022, 1, 0, 0, + 0, 1319, 10033, 1, 0, 0, 0, 1321, 10041, 1, 0, 0, 0, 1323, 10049, 1, 0, + 0, 0, 1325, 10059, 1, 0, 0, 0, 1327, 10069, 1, 0, 0, 0, 1329, 10081, 1, + 0, 0, 0, 1331, 10098, 1, 0, 0, 0, 1333, 10107, 1, 0, 0, 0, 1335, 10117, + 1, 0, 0, 0, 1337, 10136, 1, 0, 0, 0, 1339, 10147, 1, 0, 0, 0, 1341, 10163, + 1, 0, 0, 0, 1343, 10171, 1, 0, 0, 0, 1345, 10189, 1, 0, 0, 0, 1347, 10196, + 1, 0, 0, 0, 1349, 10204, 1, 0, 0, 0, 1351, 10217, 1, 0, 0, 0, 1353, 10226, + 1, 0, 0, 0, 1355, 10231, 1, 0, 0, 0, 1357, 10238, 1, 0, 0, 0, 1359, 10263, + 1, 0, 0, 0, 1361, 10283, 1, 0, 0, 0, 1363, 10290, 1, 0, 0, 0, 1365, 10297, + 1, 0, 0, 0, 1367, 10308, 1, 0, 0, 0, 1369, 10316, 1, 0, 0, 0, 1371, 10343, + 1, 0, 0, 0, 1373, 10351, 1, 0, 0, 0, 1375, 10363, 1, 0, 0, 0, 1377, 10384, + 1, 0, 0, 0, 1379, 10403, 1, 0, 0, 0, 1381, 10412, 1, 0, 0, 0, 1383, 10459, + 1, 0, 0, 0, 1385, 10507, 1, 0, 0, 0, 1387, 10513, 1, 0, 0, 0, 1389, 10522, + 1, 0, 0, 0, 1391, 10532, 1, 0, 0, 0, 1393, 10549, 1, 0, 0, 0, 1395, 10569, + 1, 0, 0, 0, 1397, 10577, 1, 0, 0, 0, 1399, 10585, 1, 0, 0, 0, 1401, 10594, + 1, 0, 0, 0, 1403, 10607, 1, 0, 0, 0, 1405, 10614, 1, 0, 0, 0, 1407, 10621, + 1, 0, 0, 0, 1409, 10632, 1, 0, 0, 0, 1411, 10639, 1, 0, 0, 0, 1413, 10647, + 1, 0, 0, 0, 1415, 10665, 1, 0, 0, 0, 1417, 10679, 1, 0, 0, 0, 1419, 10698, + 1, 0, 0, 0, 1421, 10717, 1, 0, 0, 0, 1423, 10729, 1, 0, 0, 0, 1425, 10737, + 1, 0, 0, 0, 1427, 10744, 1, 0, 0, 0, 1429, 10751, 1, 0, 0, 0, 1431, 10758, + 1, 0, 0, 0, 1433, 10764, 1, 0, 0, 0, 1435, 10770, 1, 0, 0, 0, 1437, 10775, + 1, 0, 0, 0, 1439, 10781, 1, 0, 0, 0, 1441, 10790, 1, 0, 0, 0, 1443, 10797, + 1, 0, 0, 0, 1445, 10802, 1, 0, 0, 0, 1447, 10806, 1, 0, 0, 0, 1449, 10815, + 1, 0, 0, 0, 1451, 10823, 1, 0, 0, 0, 1453, 10831, 1, 0, 0, 0, 1455, 10836, + 1, 0, 0, 0, 1457, 10855, 1, 0, 0, 0, 1459, 10866, 1, 0, 0, 0, 1461, 10881, + 1, 0, 0, 0, 1463, 10898, 1, 0, 0, 0, 1465, 10904, 1, 0, 0, 0, 1467, 10916, + 1, 0, 0, 0, 1469, 10921, 1, 0, 0, 0, 1471, 10926, 1, 0, 0, 0, 1473, 10933, + 1, 0, 0, 0, 1475, 10939, 1, 0, 0, 0, 1477, 10965, 1, 0, 0, 0, 1479, 10983, + 1, 0, 0, 0, 1481, 10996, 1, 0, 0, 0, 1483, 11027, 1, 0, 0, 0, 1485, 11042, + 1, 0, 0, 0, 1487, 11072, 1, 0, 0, 0, 1489, 11091, 1, 0, 0, 0, 1491, 11115, + 1, 0, 0, 0, 1493, 11142, 1, 0, 0, 0, 1495, 11168, 1, 0, 0, 0, 1497, 11204, + 1, 0, 0, 0, 1499, 11218, 1, 0, 0, 0, 1501, 11234, 1, 0, 0, 0, 1503, 11257, + 1, 0, 0, 0, 1505, 11264, 1, 0, 0, 0, 1507, 11277, 1, 0, 0, 0, 1509, 11292, + 1, 0, 0, 0, 1511, 11301, 1, 0, 0, 0, 1513, 11311, 1, 0, 0, 0, 1515, 11318, + 1, 0, 0, 0, 1517, 11326, 1, 0, 0, 0, 1519, 11333, 1, 0, 0, 0, 1521, 11338, + 1, 0, 0, 0, 1523, 11350, 1, 0, 0, 0, 1525, 11357, 1, 0, 0, 0, 1527, 11364, + 1, 0, 0, 0, 1529, 11374, 1, 0, 0, 0, 1531, 11389, 1, 0, 0, 0, 1533, 11404, + 1, 0, 0, 0, 1535, 11412, 1, 0, 0, 0, 1537, 11419, 1, 0, 0, 0, 1539, 11426, + 1, 0, 0, 0, 1541, 11435, 1, 0, 0, 0, 1543, 11449, 1, 0, 0, 0, 1545, 11454, + 1, 0, 0, 0, 1547, 11461, 1, 0, 0, 0, 1549, 11466, 1, 0, 0, 0, 1551, 11475, + 1, 0, 0, 0, 1553, 11485, 1, 0, 0, 0, 1555, 11492, 1, 0, 0, 0, 1557, 11500, + 1, 0, 0, 0, 1559, 11508, 1, 0, 0, 0, 1561, 11534, 1, 0, 0, 0, 1563, 11549, + 1, 0, 0, 0, 1565, 11578, 1, 0, 0, 0, 1567, 11582, 1, 0, 0, 0, 1569, 11587, + 1, 0, 0, 0, 1571, 11595, 1, 0, 0, 0, 1573, 11601, 1, 0, 0, 0, 1575, 11608, + 1, 0, 0, 0, 1577, 11615, 1, 0, 0, 0, 1579, 11634, 1, 0, 0, 0, 1581, 11639, + 1, 0, 0, 0, 1583, 11648, 1, 0, 0, 0, 1585, 11661, 1, 0, 0, 0, 1587, 11675, + 1, 0, 0, 0, 1589, 11688, 1, 0, 0, 0, 1591, 11706, 1, 0, 0, 0, 1593, 11716, + 1, 0, 0, 0, 1595, 11723, 1, 0, 0, 0, 1597, 11755, 1, 0, 0, 0, 1599, 11767, + 1, 0, 0, 0, 1601, 11772, 1, 0, 0, 0, 1603, 11783, 1, 0, 0, 0, 1605, 11788, + 1, 0, 0, 0, 1607, 11805, 1, 0, 0, 0, 1609, 11826, 1, 0, 0, 0, 1611, 11836, + 1, 0, 0, 0, 1613, 11852, 1, 0, 0, 0, 1615, 11864, 1, 0, 0, 0, 1617, 11870, + 1, 0, 0, 0, 1619, 11877, 1, 0, 0, 0, 1621, 11896, 1, 0, 0, 0, 1623, 11901, + 1, 0, 0, 0, 1625, 11909, 1, 0, 0, 0, 1627, 11916, 1, 0, 0, 0, 1629, 11935, + 1, 0, 0, 0, 1631, 11941, 1, 0, 0, 0, 1633, 11948, 1, 0, 0, 0, 1635, 11962, + 1, 0, 0, 0, 1637, 11968, 1, 0, 0, 0, 1639, 11979, 1, 0, 0, 0, 1641, 11983, + 1, 0, 0, 0, 1643, 11998, 1, 0, 0, 0, 1645, 12004, 1, 0, 0, 0, 1647, 12011, + 1, 0, 0, 0, 1649, 12030, 1, 0, 0, 0, 1651, 12048, 1, 0, 0, 0, 1653, 12057, + 1, 0, 0, 0, 1655, 12065, 1, 0, 0, 0, 1657, 12071, 1, 0, 0, 0, 1659, 12079, + 1, 0, 0, 0, 1661, 12086, 1, 0, 0, 0, 1663, 12097, 1, 0, 0, 0, 1665, 12113, + 1, 0, 0, 0, 1667, 12119, 1, 0, 0, 0, 1669, 12129, 1, 0, 0, 0, 1671, 12165, + 1, 0, 0, 0, 1673, 12194, 1, 0, 0, 0, 1675, 12201, 1, 0, 0, 0, 1677, 12212, + 1, 0, 0, 0, 1679, 12218, 1, 0, 0, 0, 1681, 12229, 1, 0, 0, 0, 1683, 12242, + 1, 0, 0, 0, 1685, 12249, 1, 0, 0, 0, 1687, 12260, 1, 0, 0, 0, 1689, 12266, + 1, 0, 0, 0, 1691, 12273, 1, 0, 0, 0, 1693, 12278, 1, 0, 0, 0, 1695, 12287, + 1, 0, 0, 0, 1697, 12295, 1, 0, 0, 0, 1699, 12303, 1, 0, 0, 0, 1701, 12329, + 1, 0, 0, 0, 1703, 12352, 1, 0, 0, 0, 1705, 12373, 1, 0, 0, 0, 1707, 12399, + 1, 0, 0, 0, 1709, 12419, 1, 0, 0, 0, 1711, 12436, 1, 0, 0, 0, 1713, 12440, + 1, 0, 0, 0, 1715, 12447, 1, 0, 0, 0, 1717, 12455, 1, 0, 0, 0, 1719, 12462, + 1, 0, 0, 0, 1721, 12481, 1, 0, 0, 0, 1723, 12492, 1, 0, 0, 0, 1725, 12506, + 1, 0, 0, 0, 1727, 12524, 1, 0, 0, 0, 1729, 12542, 1, 0, 0, 0, 1731, 12562, + 1, 0, 0, 0, 1733, 12569, 1, 0, 0, 0, 1735, 12579, 1, 0, 0, 0, 1737, 12583, + 1, 0, 0, 0, 1739, 12593, 1, 0, 0, 0, 1741, 12601, 1, 0, 0, 0, 1743, 12611, + 1, 0, 0, 0, 1745, 12629, 1, 0, 0, 0, 1747, 12661, 1, 0, 0, 0, 1749, 12666, + 1, 0, 0, 0, 1751, 12673, 1, 0, 0, 0, 1753, 12687, 1, 0, 0, 0, 1755, 12696, + 1, 0, 0, 0, 1757, 12703, 1, 0, 0, 0, 1759, 12715, 1, 0, 0, 0, 1761, 12721, + 1, 0, 0, 0, 1763, 12737, 1, 0, 0, 0, 1765, 12752, 1, 0, 0, 0, 1767, 12759, + 1, 0, 0, 0, 1769, 12771, 1, 0, 0, 0, 1771, 12784, 1, 0, 0, 0, 1773, 12792, + 1, 0, 0, 0, 1775, 12796, 1, 0, 0, 0, 1777, 12801, 1, 0, 0, 0, 1779, 12808, + 1, 0, 0, 0, 1781, 12819, 1, 0, 0, 0, 1783, 12824, 1, 0, 0, 0, 1785, 12830, + 1, 0, 0, 0, 1787, 12835, 1, 0, 0, 0, 1789, 12845, 1, 0, 0, 0, 1791, 12851, + 1, 0, 0, 0, 1793, 12860, 1, 0, 0, 0, 1795, 12865, 1, 0, 0, 0, 1797, 12870, + 1, 0, 0, 0, 1799, 12875, 1, 0, 0, 0, 1801, 12883, 1, 0, 0, 0, 1803, 12892, + 1, 0, 0, 0, 1805, 12900, 1, 0, 0, 0, 1807, 12906, 1, 0, 0, 0, 1809, 12916, + 1, 0, 0, 0, 1811, 12944, 1, 0, 0, 0, 1813, 12961, 1, 0, 0, 0, 1815, 12984, + 1, 0, 0, 0, 1817, 12998, 1, 0, 0, 0, 1819, 13026, 1, 0, 0, 0, 1821, 13040, + 1, 0, 0, 0, 1823, 13068, 1, 0, 0, 0, 1825, 13092, 1, 0, 0, 0, 1827, 13115, + 1, 0, 0, 0, 1829, 13128, 1, 0, 0, 0, 1831, 13155, 1, 0, 0, 0, 1833, 13168, + 1, 0, 0, 0, 1835, 13182, 1, 0, 0, 0, 1837, 13191, 1, 0, 0, 0, 1839, 13203, + 1, 0, 0, 0, 1841, 13221, 1, 0, 0, 0, 1843, 13240, 1, 0, 0, 0, 1845, 13243, + 1, 0, 0, 0, 1847, 13254, 1, 0, 0, 0, 1849, 13262, 1, 0, 0, 0, 1851, 13266, + 1, 0, 0, 0, 1853, 13286, 1, 0, 0, 0, 1855, 13295, 1, 0, 0, 0, 1857, 13311, + 1, 0, 0, 0, 1859, 13316, 1, 0, 0, 0, 1861, 13328, 1, 0, 0, 0, 1863, 13341, + 1, 0, 0, 0, 1865, 13368, 1, 0, 0, 0, 1867, 13404, 1, 0, 0, 0, 1869, 13419, + 1, 0, 0, 0, 1871, 13441, 1, 0, 0, 0, 1873, 13451, 1, 0, 0, 0, 1875, 13461, + 1, 0, 0, 0, 1877, 13469, 1, 0, 0, 0, 1879, 13478, 1, 0, 0, 0, 1881, 13483, + 1, 0, 0, 0, 1883, 13494, 1, 0, 0, 0, 1885, 13505, 1, 0, 0, 0, 1887, 13521, + 1, 0, 0, 0, 1889, 13526, 1, 0, 0, 0, 1891, 13535, 1, 0, 0, 0, 1893, 13551, + 1, 0, 0, 0, 1895, 13563, 1, 0, 0, 0, 1897, 13567, 1, 0, 0, 0, 1899, 13576, + 1, 0, 0, 0, 1901, 13584, 1, 0, 0, 0, 1903, 13589, 1, 0, 0, 0, 1905, 13613, + 1, 0, 0, 0, 1907, 13635, 1, 0, 0, 0, 1909, 13640, 1, 0, 0, 0, 1911, 13653, + 1, 0, 0, 0, 1913, 13661, 1, 0, 0, 0, 1915, 13671, 1, 0, 0, 0, 1917, 13684, + 1, 0, 0, 0, 1919, 13687, 1, 0, 0, 0, 1921, 13697, 1, 0, 0, 0, 1923, 13707, + 1, 0, 0, 0, 1925, 13719, 1, 0, 0, 0, 1927, 13726, 1, 0, 0, 0, 1929, 13734, + 1, 0, 0, 0, 1931, 13740, 1, 0, 0, 0, 1933, 13747, 1, 0, 0, 0, 1935, 13755, + 1, 0, 0, 0, 1937, 13765, 1, 0, 0, 0, 1939, 13772, 1, 0, 0, 0, 1941, 13779, + 1, 0, 0, 0, 1943, 13789, 1, 0, 0, 0, 1945, 13797, 1, 0, 0, 0, 1947, 13804, + 1, 0, 0, 0, 1949, 13810, 1, 0, 0, 0, 1951, 13833, 1, 0, 0, 0, 1953, 13837, + 1, 0, 0, 0, 1955, 13844, 1, 0, 0, 0, 1957, 13852, 1, 0, 0, 0, 1959, 13858, + 1, 0, 0, 0, 1961, 13862, 1, 0, 0, 0, 1963, 13868, 1, 0, 0, 0, 1965, 13872, + 1, 0, 0, 0, 1967, 13877, 1, 0, 0, 0, 1969, 13882, 1, 0, 0, 0, 1971, 13892, + 1, 0, 0, 0, 1973, 13898, 1, 0, 0, 0, 1975, 13913, 1, 0, 0, 0, 1977, 13954, + 1, 0, 0, 0, 1979, 13975, 1, 0, 0, 0, 1981, 13988, 1, 0, 0, 0, 1983, 14006, + 1, 0, 0, 0, 1985, 14012, 1, 0, 0, 0, 1987, 14017, 1, 0, 0, 0, 1989, 14026, + 1, 0, 0, 0, 1991, 14037, 1, 0, 0, 0, 1993, 14053, 1, 0, 0, 0, 1995, 14063, + 1, 0, 0, 0, 1997, 14069, 1, 0, 0, 0, 1999, 14076, 1, 0, 0, 0, 2001, 14080, + 1, 0, 0, 0, 2003, 14090, 1, 0, 0, 0, 2005, 14095, 1, 0, 0, 0, 2007, 14103, + 1, 0, 0, 0, 2009, 14111, 1, 0, 0, 0, 2011, 14116, 1, 0, 0, 0, 2013, 14122, + 1, 0, 0, 0, 2015, 14136, 1, 0, 0, 0, 2017, 14147, 1, 0, 0, 0, 2019, 14156, + 1, 0, 0, 0, 2021, 14161, 1, 0, 0, 0, 2023, 14171, 1, 0, 0, 0, 2025, 14182, + 1, 0, 0, 0, 2027, 14197, 1, 0, 0, 0, 2029, 14204, 1, 0, 0, 0, 2031, 14224, + 1, 0, 0, 0, 2033, 14235, 1, 0, 0, 0, 2035, 14251, 1, 0, 0, 0, 2037, 14256, + 1, 0, 0, 0, 2039, 14262, 1, 0, 0, 0, 2041, 14267, 1, 0, 0, 0, 2043, 14274, + 1, 0, 0, 0, 2045, 14282, 1, 0, 0, 0, 2047, 14304, 1, 0, 0, 0, 2049, 14309, + 1, 0, 0, 0, 2051, 14318, 1, 0, 0, 0, 2053, 14324, 1, 0, 0, 0, 2055, 14332, + 1, 0, 0, 0, 2057, 14340, 1, 0, 0, 0, 2059, 14348, 1, 0, 0, 0, 2061, 14355, + 1, 0, 0, 0, 2063, 14361, 1, 0, 0, 0, 2065, 14365, 1, 0, 0, 0, 2067, 14371, + 1, 0, 0, 0, 2069, 14378, 1, 0, 0, 0, 2071, 14386, 1, 0, 0, 0, 2073, 14395, + 1, 0, 0, 0, 2075, 14402, 1, 0, 0, 0, 2077, 14407, 1, 0, 0, 0, 2079, 14413, + 1, 0, 0, 0, 2081, 14421, 1, 0, 0, 0, 2083, 14428, 1, 0, 0, 0, 2085, 14435, + 1, 0, 0, 0, 2087, 14443, 1, 0, 0, 0, 2089, 14451, 1, 0, 0, 0, 2091, 14464, + 1, 0, 0, 0, 2093, 14469, 1, 0, 0, 0, 2095, 14478, 1, 0, 0, 0, 2097, 14486, + 1, 0, 0, 0, 2099, 14493, 1, 0, 0, 0, 2101, 14500, 1, 0, 0, 0, 2103, 14506, + 1, 0, 0, 0, 2105, 14516, 1, 0, 0, 0, 2107, 14525, 1, 0, 0, 0, 2109, 14533, + 1, 0, 0, 0, 2111, 14547, 1, 0, 0, 0, 2113, 14555, 1, 0, 0, 0, 2115, 14565, + 1, 0, 0, 0, 2117, 14574, 1, 0, 0, 0, 2119, 14579, 1, 0, 0, 0, 2121, 14588, + 1, 0, 0, 0, 2123, 14595, 1, 0, 0, 0, 2125, 14600, 1, 0, 0, 0, 2127, 14608, + 1, 0, 0, 0, 2129, 14618, 1, 0, 0, 0, 2131, 14626, 1, 0, 0, 0, 2133, 14634, + 1, 0, 0, 0, 2135, 14642, 1, 0, 0, 0, 2137, 14649, 1, 0, 0, 0, 2139, 14655, + 1, 0, 0, 0, 2141, 14670, 1, 0, 0, 0, 2143, 14681, 1, 0, 0, 0, 2145, 14692, + 1, 0, 0, 0, 2147, 14700, 1, 0, 0, 0, 2149, 14703, 1, 0, 0, 0, 2151, 14705, + 1, 0, 0, 0, 2153, 14712, 1, 0, 0, 0, 2155, 14720, 1, 0, 0, 0, 2157, 14728, + 1, 0, 0, 0, 2159, 14737, 1, 0, 0, 0, 2161, 14748, 1, 0, 0, 0, 2163, 14756, + 1, 0, 0, 0, 2165, 14770, 1, 0, 0, 0, 2167, 14782, 1, 0, 0, 0, 2169, 14786, + 1, 0, 0, 0, 2171, 14790, 1, 0, 0, 0, 2173, 14801, 1, 0, 0, 0, 2175, 14829, + 1, 0, 0, 0, 2177, 14831, 1, 0, 0, 0, 2179, 14833, 1, 0, 0, 0, 2181, 14836, + 1, 0, 0, 0, 2183, 14839, 1, 0, 0, 0, 2185, 14842, 1, 0, 0, 0, 2187, 14845, + 1, 0, 0, 0, 2189, 14847, 1, 0, 0, 0, 2191, 14849, 1, 0, 0, 0, 2193, 14852, + 1, 0, 0, 0, 2195, 14854, 1, 0, 0, 0, 2197, 14857, 1, 0, 0, 0, 2199, 14859, + 1, 0, 0, 0, 2201, 14862, 1, 0, 0, 0, 2203, 14864, 1, 0, 0, 0, 2205, 14866, + 1, 0, 0, 0, 2207, 14868, 1, 0, 0, 0, 2209, 14872, 1, 0, 0, 0, 2211, 14874, + 1, 0, 0, 0, 2213, 14876, 1, 0, 0, 0, 2215, 14878, 1, 0, 0, 0, 2217, 14880, + 1, 0, 0, 0, 2219, 14882, 1, 0, 0, 0, 2221, 14884, 1, 0, 0, 0, 2223, 14886, + 1, 0, 0, 0, 2225, 14888, 1, 0, 0, 0, 2227, 14890, 1, 0, 0, 0, 2229, 14892, + 1, 0, 0, 0, 2231, 14895, 1, 0, 0, 0, 2233, 14897, 1, 0, 0, 0, 2235, 14899, + 1, 0, 0, 0, 2237, 14901, 1, 0, 0, 0, 2239, 14903, 1, 0, 0, 0, 2241, 14905, + 1, 0, 0, 0, 2243, 14907, 1, 0, 0, 0, 2245, 14933, 1, 0, 0, 0, 2247, 14935, + 1, 0, 0, 0, 2249, 14937, 1, 0, 0, 0, 2251, 2252, 5, 39, 0, 0, 2252, 2253, + 7, 0, 0, 0, 2253, 2254, 7, 0, 0, 0, 2254, 2255, 7, 1, 0, 0, 2255, 2256, + 5, 95, 0, 0, 2256, 2257, 7, 2, 0, 0, 2257, 2258, 7, 3, 0, 0, 2258, 2259, + 7, 4, 0, 0, 2259, 2260, 7, 5, 0, 0, 2260, 2261, 7, 6, 0, 0, 2261, 2262, + 7, 7, 0, 0, 2262, 2263, 7, 6, 0, 0, 2263, 2264, 7, 4, 0, 0, 2264, 2265, + 7, 8, 0, 0, 2265, 2266, 7, 9, 0, 0, 2266, 2267, 7, 3, 0, 0, 2267, 2268, + 5, 39, 0, 0, 2268, 2, 1, 0, 0, 0, 2269, 2270, 7, 0, 0, 0, 2270, 2271, 7, + 10, 0, 0, 2271, 2272, 7, 4, 0, 0, 2272, 2273, 7, 3, 0, 0, 2273, 2274, 7, + 11, 0, 0, 2274, 4, 1, 0, 0, 0, 2275, 2276, 7, 0, 0, 0, 2276, 2277, 7, 10, + 0, 0, 2277, 2278, 7, 4, 0, 0, 2278, 2279, 7, 3, 0, 0, 2279, 2280, 7, 11, + 0, 0, 2280, 2281, 5, 95, 0, 0, 2281, 2282, 7, 0, 0, 0, 2282, 2283, 7, 12, + 0, 0, 2283, 2284, 7, 11, 0, 0, 2284, 2285, 7, 9, 0, 0, 2285, 2286, 7, 3, + 0, 0, 2286, 2287, 5, 95, 0, 0, 2287, 2288, 7, 13, 0, 0, 2288, 2289, 7, + 0, 0, 0, 2289, 2290, 7, 6, 0, 0, 2290, 2291, 7, 11, 0, 0, 2291, 6, 1, 0, + 0, 0, 2292, 2293, 7, 0, 0, 0, 2293, 2294, 7, 10, 0, 0, 2294, 2295, 7, 4, + 0, 0, 2295, 2296, 7, 3, 0, 0, 2296, 2297, 7, 11, 0, 0, 2297, 2298, 5, 95, + 0, 0, 2298, 2299, 7, 1, 0, 0, 2299, 2300, 7, 9, 0, 0, 2300, 2301, 7, 11, + 0, 0, 2301, 2302, 7, 0, 0, 0, 2302, 2303, 7, 14, 0, 0, 2303, 2304, 7, 15, + 0, 0, 2304, 2305, 7, 9, 0, 0, 2305, 2306, 7, 1, 0, 0, 2306, 2307, 5, 95, + 0, 0, 2307, 2308, 7, 16, 0, 0, 2308, 2309, 7, 17, 0, 0, 2309, 2310, 7, + 9, 0, 0, 2310, 2311, 7, 3, 0, 0, 2311, 2312, 7, 18, 0, 0, 2312, 8, 1, 0, + 0, 0, 2313, 2314, 7, 0, 0, 0, 2314, 2315, 7, 10, 0, 0, 2315, 2316, 7, 4, + 0, 0, 2316, 2317, 7, 3, 0, 0, 2317, 2318, 7, 11, 0, 0, 2318, 2319, 5, 95, + 0, 0, 2319, 2320, 7, 7, 0, 0, 2320, 2321, 7, 11, 0, 0, 2321, 2322, 7, 0, + 0, 0, 2322, 2323, 7, 11, 0, 0, 2323, 2324, 7, 9, 0, 0, 2324, 2325, 7, 19, + 0, 0, 2325, 2326, 7, 9, 0, 0, 2326, 2327, 7, 8, 0, 0, 2327, 2328, 7, 11, + 0, 0, 2328, 10, 1, 0, 0, 0, 2329, 2330, 7, 0, 0, 0, 2330, 2331, 7, 10, + 0, 0, 2331, 2332, 7, 7, 0, 0, 2332, 2333, 7, 9, 0, 0, 2333, 2334, 7, 8, + 0, 0, 2334, 2335, 7, 11, 0, 0, 2335, 12, 1, 0, 0, 0, 2336, 2337, 7, 0, + 0, 0, 2337, 2338, 7, 10, 0, 0, 2338, 2339, 7, 7, 0, 0, 2339, 2340, 7, 4, + 0, 0, 2340, 2341, 7, 20, 0, 0, 2341, 2342, 7, 17, 0, 0, 2342, 2343, 7, + 11, 0, 0, 2343, 2344, 7, 9, 0, 0, 2344, 14, 1, 0, 0, 0, 2345, 2346, 7, + 0, 0, 0, 2346, 2347, 7, 14, 0, 0, 2347, 2348, 7, 14, 0, 0, 2348, 2349, + 7, 9, 0, 0, 2349, 2350, 7, 7, 0, 0, 2350, 2351, 7, 7, 0, 0, 2351, 16, 1, + 0, 0, 0, 2352, 2353, 7, 0, 0, 0, 2353, 2354, 7, 14, 0, 0, 2354, 2355, 7, + 14, 0, 0, 2355, 2356, 7, 4, 0, 0, 2356, 2357, 7, 17, 0, 0, 2357, 2358, + 7, 8, 0, 0, 2358, 2359, 7, 11, 0, 0, 2359, 18, 1, 0, 0, 0, 2360, 2361, + 7, 0, 0, 0, 2361, 2362, 7, 14, 0, 0, 2362, 2363, 7, 14, 0, 0, 2363, 2364, + 7, 4, 0, 0, 2364, 2365, 7, 17, 0, 0, 2365, 2366, 7, 8, 0, 0, 2366, 2367, + 7, 11, 0, 0, 2367, 2368, 7, 0, 0, 0, 2368, 2369, 7, 1, 0, 0, 2369, 2370, + 7, 19, 0, 0, 2370, 2371, 7, 6, 0, 0, 2371, 2372, 7, 8, 0, 0, 2372, 20, + 1, 0, 0, 0, 2373, 2374, 7, 0, 0, 0, 2374, 2375, 7, 14, 0, 0, 2375, 2376, + 7, 14, 0, 0, 2376, 2377, 7, 4, 0, 0, 2377, 2378, 7, 17, 0, 0, 2378, 2379, + 7, 8, 0, 0, 2379, 2380, 7, 11, 0, 0, 2380, 2381, 7, 7, 0, 0, 2381, 22, + 1, 0, 0, 0, 2382, 2383, 7, 0, 0, 0, 2383, 2384, 7, 14, 0, 0, 2384, 2385, + 7, 11, 0, 0, 2385, 2386, 7, 6, 0, 0, 2386, 2387, 7, 4, 0, 0, 2387, 2388, + 7, 8, 0, 0, 2388, 24, 1, 0, 0, 0, 2389, 2390, 7, 0, 0, 0, 2390, 2391, 7, + 14, 0, 0, 2391, 2392, 7, 11, 0, 0, 2392, 2393, 7, 6, 0, 0, 2393, 2394, + 7, 5, 0, 0, 2394, 2395, 7, 9, 0, 0, 2395, 26, 1, 0, 0, 0, 2396, 2397, 7, + 0, 0, 0, 2397, 2398, 7, 1, 0, 0, 2398, 2399, 7, 1, 0, 0, 2399, 28, 1, 0, + 0, 0, 2400, 2401, 7, 0, 0, 0, 2401, 2402, 7, 1, 0, 0, 2402, 2403, 7, 19, + 0, 0, 2403, 2404, 7, 6, 0, 0, 2404, 2405, 7, 8, 0, 0, 2405, 2406, 7, 6, + 0, 0, 2406, 2407, 7, 7, 0, 0, 2407, 2408, 7, 11, 0, 0, 2408, 2409, 7, 9, + 0, 0, 2409, 2410, 7, 3, 0, 0, 2410, 30, 1, 0, 0, 0, 2411, 2412, 7, 0, 0, + 0, 2412, 2413, 7, 1, 0, 0, 2413, 2414, 7, 19, 0, 0, 2414, 2415, 7, 6, 0, + 0, 2415, 2416, 7, 8, 0, 0, 2416, 2417, 5, 95, 0, 0, 2417, 2418, 7, 8, 0, + 0, 2418, 2419, 7, 0, 0, 0, 2419, 2420, 7, 19, 0, 0, 2420, 2421, 7, 9, 0, + 0, 2421, 32, 1, 0, 0, 0, 2422, 2423, 7, 0, 0, 0, 2423, 2424, 7, 1, 0, 0, + 2424, 2425, 7, 19, 0, 0, 2425, 2426, 7, 6, 0, 0, 2426, 2427, 7, 8, 0, 0, + 2427, 2428, 5, 95, 0, 0, 2428, 2429, 7, 2, 0, 0, 2429, 2430, 7, 0, 0, 0, + 2430, 2431, 7, 7, 0, 0, 2431, 2432, 7, 7, 0, 0, 2432, 2433, 7, 13, 0, 0, + 2433, 2434, 7, 4, 0, 0, 2434, 2435, 7, 3, 0, 0, 2435, 2436, 7, 1, 0, 0, + 2436, 34, 1, 0, 0, 0, 2437, 2438, 7, 0, 0, 0, 2438, 2439, 7, 9, 0, 0, 2439, + 2440, 7, 7, 0, 0, 2440, 36, 1, 0, 0, 0, 2441, 2442, 7, 0, 0, 0, 2442, 2443, + 7, 12, 0, 0, 2443, 2444, 7, 11, 0, 0, 2444, 2445, 7, 9, 0, 0, 2445, 2446, + 7, 3, 0, 0, 2446, 38, 1, 0, 0, 0, 2447, 2448, 7, 0, 0, 0, 2448, 2449, 7, + 21, 0, 0, 2449, 2450, 7, 21, 0, 0, 2450, 2451, 7, 3, 0, 0, 2451, 2452, + 7, 9, 0, 0, 2452, 2453, 7, 21, 0, 0, 2453, 2454, 7, 0, 0, 0, 2454, 2455, + 7, 11, 0, 0, 2455, 2456, 7, 9, 0, 0, 2456, 40, 1, 0, 0, 0, 2457, 2458, + 7, 0, 0, 0, 2458, 2459, 7, 20, 0, 0, 2459, 2460, 7, 9, 0, 0, 2460, 2461, + 7, 3, 0, 0, 2461, 2462, 7, 11, 0, 0, 2462, 42, 1, 0, 0, 0, 2463, 2464, + 7, 0, 0, 0, 2464, 2465, 7, 20, 0, 0, 2465, 2466, 7, 9, 0, 0, 2466, 2467, + 7, 3, 0, 0, 2467, 2468, 7, 11, 0, 0, 2468, 2469, 7, 7, 0, 0, 2469, 44, + 1, 0, 0, 0, 2470, 2471, 7, 0, 0, 0, 2471, 2472, 7, 20, 0, 0, 2472, 2473, + 7, 20, 0, 0, 2473, 46, 1, 0, 0, 0, 2474, 2475, 7, 0, 0, 0, 2475, 2476, + 7, 20, 0, 0, 2476, 2477, 7, 20, 0, 0, 2477, 2478, 7, 4, 0, 0, 2478, 2479, + 7, 13, 0, 0, 2479, 2480, 7, 9, 0, 0, 2480, 2481, 7, 1, 0, 0, 2481, 48, + 1, 0, 0, 0, 2482, 2483, 7, 0, 0, 0, 2483, 2484, 7, 20, 0, 0, 2484, 2485, + 7, 20, 0, 0, 2485, 2486, 7, 4, 0, 0, 2486, 2487, 7, 13, 0, 0, 2487, 2488, + 7, 9, 0, 0, 2488, 2489, 7, 1, 0, 0, 2489, 2490, 5, 95, 0, 0, 2490, 2491, + 7, 0, 0, 0, 2491, 2492, 7, 14, 0, 0, 2492, 2493, 7, 14, 0, 0, 2493, 2494, + 7, 4, 0, 0, 2494, 2495, 7, 17, 0, 0, 2495, 2496, 7, 8, 0, 0, 2496, 2497, + 7, 11, 0, 0, 2497, 2498, 7, 7, 0, 0, 2498, 50, 1, 0, 0, 0, 2499, 2500, + 7, 0, 0, 0, 2500, 2501, 7, 20, 0, 0, 2501, 2502, 7, 20, 0, 0, 2502, 2503, + 7, 4, 0, 0, 2503, 2504, 7, 13, 0, 0, 2504, 2505, 7, 9, 0, 0, 2505, 2506, + 7, 1, 0, 0, 2506, 2507, 5, 95, 0, 0, 2507, 2508, 7, 1, 0, 0, 2508, 2509, + 7, 0, 0, 0, 2509, 2510, 7, 11, 0, 0, 2510, 2511, 7, 0, 0, 0, 2511, 2512, + 7, 10, 0, 0, 2512, 2513, 7, 0, 0, 0, 2513, 2514, 7, 7, 0, 0, 2514, 2515, + 7, 9, 0, 0, 2515, 2516, 7, 7, 0, 0, 2516, 52, 1, 0, 0, 0, 2517, 2518, 7, + 0, 0, 0, 2518, 2519, 7, 20, 0, 0, 2519, 2520, 7, 20, 0, 0, 2520, 2521, + 7, 4, 0, 0, 2521, 2522, 7, 13, 0, 0, 2522, 2523, 7, 9, 0, 0, 2523, 2524, + 7, 1, 0, 0, 2524, 2525, 5, 95, 0, 0, 2525, 2526, 7, 6, 0, 0, 2526, 2527, + 7, 8, 0, 0, 2527, 2528, 7, 11, 0, 0, 2528, 2529, 7, 9, 0, 0, 2529, 2530, + 7, 21, 0, 0, 2530, 2531, 7, 3, 0, 0, 2531, 2532, 7, 0, 0, 0, 2532, 2533, + 7, 11, 0, 0, 2533, 2534, 7, 6, 0, 0, 2534, 2535, 7, 4, 0, 0, 2535, 2536, + 7, 8, 0, 0, 2536, 2537, 5, 95, 0, 0, 2537, 2538, 7, 11, 0, 0, 2538, 2539, + 7, 18, 0, 0, 2539, 2540, 7, 2, 0, 0, 2540, 2541, 7, 9, 0, 0, 2541, 2542, + 7, 7, 0, 0, 2542, 54, 1, 0, 0, 0, 2543, 2544, 7, 0, 0, 0, 2544, 2545, 7, + 20, 0, 0, 2545, 2546, 7, 20, 0, 0, 2546, 2547, 7, 4, 0, 0, 2547, 2548, + 7, 13, 0, 0, 2548, 2549, 7, 9, 0, 0, 2549, 2550, 7, 1, 0, 0, 2550, 2551, + 5, 95, 0, 0, 2551, 2552, 7, 6, 0, 0, 2552, 2553, 7, 2, 0, 0, 2553, 2554, + 5, 95, 0, 0, 2554, 2555, 7, 20, 0, 0, 2555, 2556, 7, 6, 0, 0, 2556, 2557, + 7, 7, 0, 0, 2557, 2558, 7, 11, 0, 0, 2558, 56, 1, 0, 0, 0, 2559, 2560, + 7, 0, 0, 0, 2560, 2561, 7, 20, 0, 0, 2561, 2562, 7, 20, 0, 0, 2562, 2563, + 7, 4, 0, 0, 2563, 2564, 7, 13, 0, 0, 2564, 2565, 7, 9, 0, 0, 2565, 2566, + 7, 1, 0, 0, 2566, 2567, 5, 95, 0, 0, 2567, 2568, 7, 7, 0, 0, 2568, 2569, + 7, 15, 0, 0, 2569, 2570, 7, 0, 0, 0, 2570, 2571, 7, 3, 0, 0, 2571, 2572, + 7, 9, 0, 0, 2572, 2573, 7, 7, 0, 0, 2573, 58, 1, 0, 0, 0, 2574, 2575, 7, + 0, 0, 0, 2575, 2576, 7, 20, 0, 0, 2576, 2577, 7, 20, 0, 0, 2577, 2578, + 7, 4, 0, 0, 2578, 2579, 7, 13, 0, 0, 2579, 2580, 7, 9, 0, 0, 2580, 2581, + 7, 1, 0, 0, 2581, 2582, 5, 95, 0, 0, 2582, 2583, 7, 5, 0, 0, 2583, 2584, + 7, 0, 0, 0, 2584, 2585, 7, 20, 0, 0, 2585, 2586, 7, 17, 0, 0, 2586, 2587, + 7, 9, 0, 0, 2587, 2588, 7, 7, 0, 0, 2588, 60, 1, 0, 0, 0, 2589, 2590, 7, + 0, 0, 0, 2590, 2591, 7, 20, 0, 0, 2591, 2592, 7, 20, 0, 0, 2592, 2593, + 7, 4, 0, 0, 2593, 2594, 7, 13, 0, 0, 2594, 2595, 5, 95, 0, 0, 2595, 2596, + 7, 14, 0, 0, 2596, 2597, 7, 20, 0, 0, 2597, 2598, 7, 6, 0, 0, 2598, 2599, + 7, 9, 0, 0, 2599, 2600, 7, 8, 0, 0, 2600, 2601, 7, 11, 0, 0, 2601, 2602, + 5, 95, 0, 0, 2602, 2603, 7, 19, 0, 0, 2603, 2604, 7, 12, 0, 0, 2604, 2605, + 7, 0, 0, 0, 2605, 2606, 5, 95, 0, 0, 2606, 2607, 7, 14, 0, 0, 2607, 2608, + 7, 0, 0, 0, 2608, 2609, 7, 14, 0, 0, 2609, 2610, 7, 15, 0, 0, 2610, 2611, + 7, 6, 0, 0, 2611, 2612, 7, 8, 0, 0, 2612, 2613, 7, 21, 0, 0, 2613, 62, + 1, 0, 0, 0, 2614, 2615, 7, 0, 0, 0, 2615, 2616, 7, 20, 0, 0, 2616, 2617, + 7, 20, 0, 0, 2617, 2618, 7, 4, 0, 0, 2618, 2619, 7, 13, 0, 0, 2619, 2620, + 5, 95, 0, 0, 2620, 2621, 7, 14, 0, 0, 2621, 2622, 7, 4, 0, 0, 2622, 2623, + 7, 8, 0, 0, 2623, 2624, 7, 8, 0, 0, 2624, 2625, 7, 9, 0, 0, 2625, 2626, + 7, 14, 0, 0, 2626, 2627, 7, 11, 0, 0, 2627, 2628, 7, 6, 0, 0, 2628, 2629, + 7, 4, 0, 0, 2629, 2630, 7, 8, 0, 0, 2630, 2631, 7, 7, 0, 0, 2631, 64, 1, + 0, 0, 0, 2632, 2633, 7, 0, 0, 0, 2633, 2634, 7, 20, 0, 0, 2634, 2635, 7, + 20, 0, 0, 2635, 2636, 7, 4, 0, 0, 2636, 2637, 7, 13, 0, 0, 2637, 2638, + 5, 95, 0, 0, 2638, 2639, 7, 1, 0, 0, 2639, 2640, 7, 17, 0, 0, 2640, 2641, + 7, 2, 0, 0, 2641, 2642, 7, 20, 0, 0, 2642, 2643, 7, 6, 0, 0, 2643, 2644, + 7, 14, 0, 0, 2644, 2645, 7, 0, 0, 0, 2645, 2646, 7, 11, 0, 0, 2646, 2647, + 7, 9, 0, 0, 2647, 66, 1, 0, 0, 0, 2648, 2649, 7, 0, 0, 0, 2649, 2650, 7, + 20, 0, 0, 2650, 2651, 7, 20, 0, 0, 2651, 2652, 7, 4, 0, 0, 2652, 2653, + 7, 13, 0, 0, 2653, 2654, 5, 95, 0, 0, 2654, 2655, 7, 6, 0, 0, 2655, 2656, + 7, 1, 0, 0, 2656, 2657, 5, 95, 0, 0, 2657, 2658, 7, 11, 0, 0, 2658, 2659, + 7, 4, 0, 0, 2659, 2660, 7, 22, 0, 0, 2660, 2661, 7, 9, 0, 0, 2661, 2662, + 7, 8, 0, 0, 2662, 68, 1, 0, 0, 0, 2663, 2664, 7, 0, 0, 0, 2664, 2665, 7, + 20, 0, 0, 2665, 2666, 7, 20, 0, 0, 2666, 2667, 7, 4, 0, 0, 2667, 2668, + 7, 13, 0, 0, 2668, 2669, 5, 95, 0, 0, 2669, 2670, 7, 19, 0, 0, 2670, 2671, + 7, 17, 0, 0, 2671, 2672, 7, 20, 0, 0, 2672, 2673, 7, 11, 0, 0, 2673, 2674, + 7, 6, 0, 0, 2674, 2675, 7, 2, 0, 0, 2675, 2676, 7, 20, 0, 0, 2676, 2677, + 7, 9, 0, 0, 2677, 2678, 5, 95, 0, 0, 2678, 2679, 7, 9, 0, 0, 2679, 2680, + 7, 5, 0, 0, 2680, 2681, 7, 9, 0, 0, 2681, 2682, 7, 8, 0, 0, 2682, 2683, + 7, 11, 0, 0, 2683, 2684, 5, 95, 0, 0, 2684, 2685, 7, 20, 0, 0, 2685, 2686, + 7, 4, 0, 0, 2686, 2687, 7, 7, 0, 0, 2687, 2688, 7, 7, 0, 0, 2688, 70, 1, + 0, 0, 0, 2689, 2690, 7, 0, 0, 0, 2690, 2691, 7, 20, 0, 0, 2691, 2692, 7, + 20, 0, 0, 2692, 2693, 7, 4, 0, 0, 2693, 2694, 7, 13, 0, 0, 2694, 2695, + 5, 95, 0, 0, 2695, 2696, 7, 4, 0, 0, 2696, 2697, 7, 5, 0, 0, 2697, 2698, + 7, 9, 0, 0, 2698, 2699, 7, 3, 0, 0, 2699, 2700, 7, 20, 0, 0, 2700, 2701, + 7, 0, 0, 0, 2701, 2702, 7, 2, 0, 0, 2702, 2703, 7, 2, 0, 0, 2703, 2704, + 7, 6, 0, 0, 2704, 2705, 7, 8, 0, 0, 2705, 2706, 7, 21, 0, 0, 2706, 2707, + 5, 95, 0, 0, 2707, 2708, 7, 9, 0, 0, 2708, 2709, 7, 23, 0, 0, 2709, 2710, + 7, 9, 0, 0, 2710, 2711, 7, 14, 0, 0, 2711, 2712, 7, 17, 0, 0, 2712, 2713, + 7, 11, 0, 0, 2713, 2714, 7, 6, 0, 0, 2714, 2715, 7, 4, 0, 0, 2715, 2716, + 7, 8, 0, 0, 2716, 72, 1, 0, 0, 0, 2717, 2718, 7, 0, 0, 0, 2718, 2719, 7, + 20, 0, 0, 2719, 2720, 7, 20, 0, 0, 2720, 2721, 7, 4, 0, 0, 2721, 2722, + 7, 13, 0, 0, 2722, 2723, 5, 95, 0, 0, 2723, 2724, 7, 7, 0, 0, 2724, 2725, + 7, 6, 0, 0, 2725, 2726, 7, 8, 0, 0, 2726, 2727, 7, 21, 0, 0, 2727, 2728, + 7, 20, 0, 0, 2728, 2729, 7, 9, 0, 0, 2729, 2730, 5, 95, 0, 0, 2730, 2731, + 7, 9, 0, 0, 2731, 2732, 7, 5, 0, 0, 2732, 2733, 7, 9, 0, 0, 2733, 2734, + 7, 8, 0, 0, 2734, 2735, 7, 11, 0, 0, 2735, 2736, 5, 95, 0, 0, 2736, 2737, + 7, 20, 0, 0, 2737, 2738, 7, 4, 0, 0, 2738, 2739, 7, 7, 0, 0, 2739, 2740, + 7, 7, 0, 0, 2740, 74, 1, 0, 0, 0, 2741, 2742, 7, 0, 0, 0, 2742, 2743, 7, + 20, 0, 0, 2743, 2744, 7, 11, 0, 0, 2744, 2745, 7, 9, 0, 0, 2745, 2746, + 7, 3, 0, 0, 2746, 76, 1, 0, 0, 0, 2747, 2748, 7, 0, 0, 0, 2748, 2749, 7, + 20, 0, 0, 2749, 2750, 7, 13, 0, 0, 2750, 2751, 7, 0, 0, 0, 2751, 2752, + 7, 18, 0, 0, 2752, 2753, 7, 7, 0, 0, 2753, 78, 1, 0, 0, 0, 2754, 2755, + 7, 0, 0, 0, 2755, 2756, 7, 8, 0, 0, 2756, 2757, 7, 1, 0, 0, 2757, 80, 1, + 0, 0, 0, 2758, 2759, 7, 0, 0, 0, 2759, 2760, 7, 8, 0, 0, 2760, 2761, 7, + 4, 0, 0, 2761, 2762, 7, 8, 0, 0, 2762, 2763, 7, 18, 0, 0, 2763, 2764, 7, + 19, 0, 0, 2764, 2765, 7, 4, 0, 0, 2765, 2766, 7, 17, 0, 0, 2766, 2767, + 7, 7, 0, 0, 2767, 82, 1, 0, 0, 0, 2768, 2769, 7, 0, 0, 0, 2769, 2770, 7, + 8, 0, 0, 2770, 2771, 7, 7, 0, 0, 2771, 2772, 7, 6, 0, 0, 2772, 2773, 5, + 95, 0, 0, 2773, 2774, 7, 1, 0, 0, 2774, 2775, 7, 9, 0, 0, 2775, 2776, 7, + 12, 0, 0, 2776, 2777, 7, 0, 0, 0, 2777, 2778, 7, 17, 0, 0, 2778, 2779, + 7, 20, 0, 0, 2779, 2780, 7, 11, 0, 0, 2780, 2781, 7, 7, 0, 0, 2781, 84, + 1, 0, 0, 0, 2782, 2783, 7, 0, 0, 0, 2783, 2784, 7, 8, 0, 0, 2784, 2785, + 7, 18, 0, 0, 2785, 86, 1, 0, 0, 0, 2786, 2787, 7, 0, 0, 0, 2787, 2788, + 7, 2, 0, 0, 2788, 2789, 7, 6, 0, 0, 2789, 88, 1, 0, 0, 0, 2790, 2791, 7, + 0, 0, 0, 2791, 2792, 7, 2, 0, 0, 2792, 2793, 7, 6, 0, 0, 2793, 2794, 5, + 95, 0, 0, 2794, 2795, 7, 0, 0, 0, 2795, 2796, 7, 20, 0, 0, 2796, 2797, + 7, 20, 0, 0, 2797, 2798, 7, 4, 0, 0, 2798, 2799, 7, 13, 0, 0, 2799, 2800, + 7, 9, 0, 0, 2800, 2801, 7, 1, 0, 0, 2801, 2802, 5, 95, 0, 0, 2802, 2803, + 7, 2, 0, 0, 2803, 2804, 7, 3, 0, 0, 2804, 2805, 7, 9, 0, 0, 2805, 2806, + 7, 12, 0, 0, 2806, 2807, 7, 6, 0, 0, 2807, 2808, 7, 23, 0, 0, 2808, 2809, + 7, 9, 0, 0, 2809, 2810, 7, 7, 0, 0, 2810, 90, 1, 0, 0, 0, 2811, 2812, 7, + 0, 0, 0, 2812, 2813, 7, 2, 0, 0, 2813, 2814, 7, 6, 0, 0, 2814, 2815, 5, + 95, 0, 0, 2815, 2816, 7, 0, 0, 0, 2816, 2817, 7, 13, 0, 0, 2817, 2818, + 7, 7, 0, 0, 2818, 2819, 5, 95, 0, 0, 2819, 2820, 7, 3, 0, 0, 2820, 2821, + 7, 4, 0, 0, 2821, 2822, 7, 20, 0, 0, 2822, 2823, 7, 9, 0, 0, 2823, 2824, + 5, 95, 0, 0, 2824, 2825, 7, 0, 0, 0, 2825, 2826, 7, 3, 0, 0, 2826, 2827, + 7, 8, 0, 0, 2827, 92, 1, 0, 0, 0, 2828, 2829, 7, 0, 0, 0, 2829, 2830, 7, + 2, 0, 0, 2830, 2831, 7, 6, 0, 0, 2831, 2832, 5, 95, 0, 0, 2832, 2833, 7, + 10, 0, 0, 2833, 2834, 7, 20, 0, 0, 2834, 2835, 7, 4, 0, 0, 2835, 2836, + 7, 14, 0, 0, 2836, 2837, 7, 22, 0, 0, 2837, 2838, 7, 9, 0, 0, 2838, 2839, + 7, 1, 0, 0, 2839, 2840, 5, 95, 0, 0, 2840, 2841, 7, 2, 0, 0, 2841, 2842, + 7, 3, 0, 0, 2842, 2843, 7, 9, 0, 0, 2843, 2844, 7, 12, 0, 0, 2844, 2845, + 7, 6, 0, 0, 2845, 2846, 7, 23, 0, 0, 2846, 2847, 7, 9, 0, 0, 2847, 2848, + 7, 7, 0, 0, 2848, 94, 1, 0, 0, 0, 2849, 2850, 7, 0, 0, 0, 2850, 2851, 7, + 2, 0, 0, 2851, 2852, 7, 6, 0, 0, 2852, 2853, 5, 95, 0, 0, 2853, 2854, 7, + 6, 0, 0, 2854, 2855, 7, 8, 0, 0, 2855, 2856, 7, 11, 0, 0, 2856, 2857, 7, + 9, 0, 0, 2857, 2858, 7, 21, 0, 0, 2858, 2859, 7, 3, 0, 0, 2859, 2860, 7, + 0, 0, 0, 2860, 2861, 7, 11, 0, 0, 2861, 2862, 7, 6, 0, 0, 2862, 2863, 7, + 4, 0, 0, 2863, 2864, 7, 8, 0, 0, 2864, 96, 1, 0, 0, 0, 2865, 2866, 7, 0, + 0, 0, 2866, 2867, 7, 2, 0, 0, 2867, 2868, 7, 6, 0, 0, 2868, 2869, 5, 95, + 0, 0, 2869, 2870, 7, 22, 0, 0, 2870, 2871, 7, 9, 0, 0, 2871, 2872, 7, 18, + 0, 0, 2872, 98, 1, 0, 0, 0, 2873, 2874, 7, 0, 0, 0, 2874, 2875, 7, 2, 0, + 0, 2875, 2876, 7, 6, 0, 0, 2876, 2877, 5, 95, 0, 0, 2877, 2878, 7, 2, 0, + 0, 2878, 2879, 7, 3, 0, 0, 2879, 2880, 7, 4, 0, 0, 2880, 2881, 7, 5, 0, + 0, 2881, 2882, 7, 6, 0, 0, 2882, 2883, 7, 1, 0, 0, 2883, 2884, 7, 9, 0, + 0, 2884, 2885, 7, 3, 0, 0, 2885, 100, 1, 0, 0, 0, 2886, 2887, 7, 0, 0, + 0, 2887, 2888, 7, 2, 0, 0, 2888, 2889, 7, 2, 0, 0, 2889, 2890, 7, 9, 0, + 0, 2890, 2891, 7, 8, 0, 0, 2891, 2892, 7, 1, 0, 0, 2892, 102, 1, 0, 0, + 0, 2893, 2894, 7, 0, 0, 0, 2894, 2895, 7, 2, 0, 0, 2895, 2896, 7, 2, 0, + 0, 2896, 2897, 7, 9, 0, 0, 2897, 2898, 7, 8, 0, 0, 2898, 2899, 7, 1, 0, + 0, 2899, 2900, 5, 95, 0, 0, 2900, 2901, 7, 4, 0, 0, 2901, 2902, 7, 8, 0, + 0, 2902, 2903, 7, 20, 0, 0, 2903, 2904, 7, 18, 0, 0, 2904, 104, 1, 0, 0, + 0, 2905, 2906, 7, 0, 0, 0, 2906, 2907, 7, 2, 0, 0, 2907, 2908, 7, 2, 0, + 0, 2908, 2909, 7, 20, 0, 0, 2909, 2910, 7, 6, 0, 0, 2910, 2911, 7, 14, + 0, 0, 2911, 2912, 7, 0, 0, 0, 2912, 2913, 7, 11, 0, 0, 2913, 2914, 7, 6, + 0, 0, 2914, 2915, 7, 4, 0, 0, 2915, 2916, 7, 8, 0, 0, 2916, 106, 1, 0, + 0, 0, 2917, 2918, 7, 0, 0, 0, 2918, 2919, 7, 2, 0, 0, 2919, 2920, 7, 2, + 0, 0, 2920, 2921, 7, 20, 0, 0, 2921, 2922, 7, 18, 0, 0, 2922, 108, 1, 0, + 0, 0, 2923, 2924, 7, 0, 0, 0, 2924, 2925, 7, 2, 0, 0, 2925, 2926, 7, 2, + 0, 0, 2926, 2927, 5, 95, 0, 0, 2927, 2928, 7, 8, 0, 0, 2928, 2929, 7, 0, + 0, 0, 2929, 2930, 7, 19, 0, 0, 2930, 2931, 7, 9, 0, 0, 2931, 110, 1, 0, + 0, 0, 2932, 2933, 7, 0, 0, 0, 2933, 2934, 7, 7, 0, 0, 2934, 112, 1, 0, + 0, 0, 2935, 2936, 7, 0, 0, 0, 2936, 2937, 7, 7, 0, 0, 2937, 2938, 7, 14, + 0, 0, 2938, 114, 1, 0, 0, 0, 2939, 2940, 7, 0, 0, 0, 2940, 2941, 7, 11, + 0, 0, 2941, 2942, 7, 11, 0, 0, 2942, 2943, 7, 0, 0, 0, 2943, 2944, 7, 14, + 0, 0, 2944, 2945, 7, 15, 0, 0, 2945, 116, 1, 0, 0, 0, 2946, 2947, 7, 0, + 0, 0, 2947, 2948, 7, 11, 0, 0, 2948, 118, 1, 0, 0, 0, 2949, 2950, 7, 0, + 0, 0, 2950, 2951, 7, 17, 0, 0, 2951, 2952, 7, 11, 0, 0, 2952, 2953, 7, + 15, 0, 0, 2953, 2954, 7, 4, 0, 0, 2954, 2955, 7, 3, 0, 0, 2955, 2956, 7, + 6, 0, 0, 2956, 2957, 7, 24, 0, 0, 2957, 2958, 7, 0, 0, 0, 2958, 2959, 7, + 11, 0, 0, 2959, 2960, 7, 6, 0, 0, 2960, 2961, 7, 4, 0, 0, 2961, 2962, 7, + 8, 0, 0, 2962, 120, 1, 0, 0, 0, 2963, 2964, 7, 0, 0, 0, 2964, 2965, 7, + 17, 0, 0, 2965, 2966, 7, 11, 0, 0, 2966, 2967, 7, 15, 0, 0, 2967, 2968, + 7, 4, 0, 0, 2968, 2969, 7, 3, 0, 0, 2969, 2970, 7, 6, 0, 0, 2970, 2971, + 7, 24, 0, 0, 2971, 2972, 7, 0, 0, 0, 2972, 2973, 7, 11, 0, 0, 2973, 2974, + 7, 6, 0, 0, 2974, 2975, 7, 4, 0, 0, 2975, 2976, 7, 8, 0, 0, 2976, 2977, + 7, 7, 0, 0, 2977, 122, 1, 0, 0, 0, 2978, 2979, 7, 0, 0, 0, 2979, 2980, + 7, 17, 0, 0, 2980, 2981, 7, 11, 0, 0, 2981, 2982, 7, 4, 0, 0, 2982, 124, + 1, 0, 0, 0, 2983, 2984, 5, 39, 0, 0, 2984, 2985, 7, 0, 0, 0, 2985, 2986, + 7, 17, 0, 0, 2986, 2987, 7, 11, 0, 0, 2987, 2988, 7, 4, 0, 0, 2988, 2989, + 5, 39, 0, 0, 2989, 126, 1, 0, 0, 0, 2990, 2991, 7, 0, 0, 0, 2991, 2992, + 7, 17, 0, 0, 2992, 2993, 7, 11, 0, 0, 2993, 2994, 7, 4, 0, 0, 2994, 2995, + 7, 14, 0, 0, 2995, 2996, 7, 4, 0, 0, 2996, 2997, 7, 19, 0, 0, 2997, 2998, + 7, 19, 0, 0, 2998, 2999, 7, 6, 0, 0, 2999, 3000, 7, 11, 0, 0, 3000, 128, + 1, 0, 0, 0, 3001, 3002, 7, 0, 0, 0, 3002, 3003, 7, 17, 0, 0, 3003, 3004, + 7, 11, 0, 0, 3004, 3005, 7, 4, 0, 0, 3005, 3006, 7, 14, 0, 0, 3006, 3007, + 7, 4, 0, 0, 3007, 3008, 7, 19, 0, 0, 3008, 3009, 7, 19, 0, 0, 3009, 3010, + 7, 6, 0, 0, 3010, 3011, 7, 11, 0, 0, 3011, 3012, 5, 95, 0, 0, 3012, 3013, + 7, 0, 0, 0, 3013, 3014, 7, 2, 0, 0, 3014, 3015, 7, 6, 0, 0, 3015, 3016, + 5, 95, 0, 0, 3016, 3017, 7, 7, 0, 0, 3017, 3018, 7, 17, 0, 0, 3018, 3019, + 7, 2, 0, 0, 3019, 3020, 7, 2, 0, 0, 3020, 3021, 7, 4, 0, 0, 3021, 3022, + 7, 3, 0, 0, 3022, 3023, 7, 11, 0, 0, 3023, 3024, 7, 9, 0, 0, 3024, 3025, + 7, 1, 0, 0, 3025, 130, 1, 0, 0, 0, 3026, 3027, 7, 0, 0, 0, 3027, 3028, + 7, 17, 0, 0, 3028, 3029, 7, 11, 0, 0, 3029, 3030, 7, 4, 0, 0, 3030, 3031, + 7, 6, 0, 0, 3031, 3032, 7, 8, 0, 0, 3032, 3033, 7, 14, 0, 0, 3033, 3034, + 7, 3, 0, 0, 3034, 3035, 7, 9, 0, 0, 3035, 3036, 7, 19, 0, 0, 3036, 3037, + 7, 9, 0, 0, 3037, 3038, 7, 8, 0, 0, 3038, 3039, 7, 11, 0, 0, 3039, 132, + 1, 0, 0, 0, 3040, 3041, 7, 0, 0, 0, 3041, 3042, 7, 17, 0, 0, 3042, 3043, + 7, 11, 0, 0, 3043, 3044, 7, 4, 0, 0, 3044, 3045, 5, 95, 0, 0, 3045, 3046, + 7, 14, 0, 0, 3046, 3047, 7, 4, 0, 0, 3047, 3048, 7, 19, 0, 0, 3048, 3049, + 7, 2, 0, 0, 3049, 3050, 7, 3, 0, 0, 3050, 3051, 7, 9, 0, 0, 3051, 3052, + 7, 7, 0, 0, 3052, 3053, 7, 7, 0, 0, 3053, 134, 1, 0, 0, 0, 3054, 3055, + 7, 0, 0, 0, 3055, 3056, 7, 17, 0, 0, 3056, 3057, 7, 11, 0, 0, 3057, 3058, + 7, 4, 0, 0, 3058, 3059, 5, 95, 0, 0, 3059, 3060, 7, 1, 0, 0, 3060, 3061, + 7, 9, 0, 0, 3061, 3062, 7, 11, 0, 0, 3062, 3063, 7, 9, 0, 0, 3063, 3064, + 7, 14, 0, 0, 3064, 3065, 7, 11, 0, 0, 3065, 136, 1, 0, 0, 0, 3066, 3067, + 7, 0, 0, 0, 3067, 3068, 7, 17, 0, 0, 3068, 3069, 7, 11, 0, 0, 3069, 3070, + 7, 4, 0, 0, 3070, 3071, 5, 95, 0, 0, 3071, 3072, 7, 6, 0, 0, 3072, 3073, + 7, 8, 0, 0, 3073, 3074, 7, 21, 0, 0, 3074, 3075, 7, 9, 0, 0, 3075, 3076, + 7, 7, 0, 0, 3076, 3077, 7, 11, 0, 0, 3077, 138, 1, 0, 0, 0, 3078, 3079, + 7, 0, 0, 0, 3079, 3080, 7, 17, 0, 0, 3080, 3081, 7, 11, 0, 0, 3081, 3082, + 7, 4, 0, 0, 3082, 3083, 5, 95, 0, 0, 3083, 3084, 7, 3, 0, 0, 3084, 3085, + 7, 9, 0, 0, 3085, 3086, 7, 12, 0, 0, 3086, 3087, 7, 3, 0, 0, 3087, 3088, + 7, 9, 0, 0, 3088, 3089, 7, 7, 0, 0, 3089, 3090, 7, 15, 0, 0, 3090, 140, + 1, 0, 0, 0, 3091, 3092, 7, 0, 0, 0, 3092, 3093, 7, 17, 0, 0, 3093, 3094, + 7, 11, 0, 0, 3094, 3095, 7, 4, 0, 0, 3095, 3096, 5, 95, 0, 0, 3096, 3097, + 7, 3, 0, 0, 3097, 3098, 7, 9, 0, 0, 3098, 3099, 7, 7, 0, 0, 3099, 3100, + 7, 17, 0, 0, 3100, 3101, 7, 19, 0, 0, 3101, 3102, 7, 9, 0, 0, 3102, 142, + 1, 0, 0, 0, 3103, 3104, 7, 0, 0, 0, 3104, 3105, 7, 17, 0, 0, 3105, 3106, + 7, 11, 0, 0, 3106, 3107, 7, 4, 0, 0, 3107, 3108, 5, 95, 0, 0, 3108, 3109, + 7, 7, 0, 0, 3109, 3110, 7, 17, 0, 0, 3110, 3111, 7, 7, 0, 0, 3111, 3112, + 7, 2, 0, 0, 3112, 3113, 7, 9, 0, 0, 3113, 3114, 7, 8, 0, 0, 3114, 3115, + 7, 1, 0, 0, 3115, 144, 1, 0, 0, 0, 3116, 3117, 7, 0, 0, 0, 3117, 3118, + 7, 5, 0, 0, 3118, 3119, 7, 21, 0, 0, 3119, 146, 1, 0, 0, 0, 3120, 3121, + 7, 0, 0, 0, 3121, 3122, 7, 5, 0, 0, 3122, 3123, 7, 3, 0, 0, 3123, 3124, + 7, 4, 0, 0, 3124, 148, 1, 0, 0, 0, 3125, 3126, 5, 39, 0, 0, 3126, 3127, + 7, 0, 0, 0, 3127, 3128, 7, 5, 0, 0, 3128, 3129, 7, 3, 0, 0, 3129, 3130, + 7, 4, 0, 0, 3130, 3131, 5, 39, 0, 0, 3131, 150, 1, 0, 0, 0, 3132, 3133, + 7, 0, 0, 0, 3133, 3134, 7, 13, 0, 0, 3134, 3135, 7, 7, 0, 0, 3135, 3136, + 5, 95, 0, 0, 3136, 3137, 7, 22, 0, 0, 3137, 3138, 7, 9, 0, 0, 3138, 3139, + 7, 18, 0, 0, 3139, 3140, 5, 95, 0, 0, 3140, 3141, 7, 6, 0, 0, 3141, 3142, + 7, 1, 0, 0, 3142, 152, 1, 0, 0, 0, 3143, 3144, 7, 0, 0, 0, 3144, 3145, + 7, 13, 0, 0, 3145, 3146, 7, 7, 0, 0, 3146, 3147, 5, 95, 0, 0, 3147, 3148, + 7, 3, 0, 0, 3148, 3149, 7, 4, 0, 0, 3149, 3150, 7, 20, 0, 0, 3150, 3151, + 7, 9, 0, 0, 3151, 154, 1, 0, 0, 0, 3152, 3153, 7, 0, 0, 0, 3153, 3154, + 7, 13, 0, 0, 3154, 3155, 7, 7, 0, 0, 3155, 3156, 5, 95, 0, 0, 3156, 3157, + 7, 7, 0, 0, 3157, 3158, 7, 9, 0, 0, 3158, 3159, 7, 14, 0, 0, 3159, 3160, + 7, 3, 0, 0, 3160, 3161, 7, 9, 0, 0, 3161, 3162, 7, 11, 0, 0, 3162, 3163, + 5, 95, 0, 0, 3163, 3164, 7, 22, 0, 0, 3164, 3165, 7, 9, 0, 0, 3165, 3166, + 7, 18, 0, 0, 3166, 156, 1, 0, 0, 0, 3167, 3168, 7, 0, 0, 0, 3168, 3169, + 7, 13, 0, 0, 3169, 3170, 7, 7, 0, 0, 3170, 3171, 5, 95, 0, 0, 3171, 3172, + 7, 7, 0, 0, 3172, 3173, 7, 8, 0, 0, 3173, 3174, 7, 7, 0, 0, 3174, 158, + 1, 0, 0, 0, 3175, 3176, 7, 0, 0, 0, 3176, 3177, 7, 13, 0, 0, 3177, 3178, + 7, 7, 0, 0, 3178, 3179, 5, 95, 0, 0, 3179, 3180, 7, 7, 0, 0, 3180, 3181, + 7, 8, 0, 0, 3181, 3182, 7, 7, 0, 0, 3182, 3183, 5, 95, 0, 0, 3183, 3184, + 7, 3, 0, 0, 3184, 3185, 7, 4, 0, 0, 3185, 3186, 7, 20, 0, 0, 3186, 3187, + 7, 9, 0, 0, 3187, 3188, 5, 95, 0, 0, 3188, 3189, 7, 0, 0, 0, 3189, 3190, + 7, 3, 0, 0, 3190, 3191, 7, 8, 0, 0, 3191, 160, 1, 0, 0, 0, 3192, 3193, + 7, 0, 0, 0, 3193, 3194, 7, 13, 0, 0, 3194, 3195, 7, 7, 0, 0, 3195, 3196, + 5, 95, 0, 0, 3196, 3197, 7, 7, 0, 0, 3197, 3198, 7, 8, 0, 0, 3198, 3199, + 7, 7, 0, 0, 3199, 3200, 5, 95, 0, 0, 3200, 3201, 7, 11, 0, 0, 3201, 3202, + 7, 4, 0, 0, 3202, 3203, 7, 2, 0, 0, 3203, 3204, 7, 6, 0, 0, 3204, 3205, + 7, 14, 0, 0, 3205, 162, 1, 0, 0, 0, 3206, 3207, 7, 0, 0, 0, 3207, 3208, + 7, 13, 0, 0, 3208, 3209, 7, 7, 0, 0, 3209, 3210, 5, 95, 0, 0, 3210, 3211, + 7, 7, 0, 0, 3211, 3212, 7, 8, 0, 0, 3212, 3213, 7, 7, 0, 0, 3213, 3214, + 5, 95, 0, 0, 3214, 3215, 7, 11, 0, 0, 3215, 3216, 7, 4, 0, 0, 3216, 3217, + 7, 2, 0, 0, 3217, 3218, 7, 6, 0, 0, 3218, 3219, 7, 14, 0, 0, 3219, 3220, + 5, 95, 0, 0, 3220, 3221, 7, 0, 0, 0, 3221, 3222, 7, 3, 0, 0, 3222, 3223, + 7, 8, 0, 0, 3223, 164, 1, 0, 0, 0, 3224, 3225, 7, 0, 0, 0, 3225, 3226, + 7, 13, 0, 0, 3226, 3227, 7, 7, 0, 0, 3227, 3228, 5, 95, 0, 0, 3228, 3229, + 7, 11, 0, 0, 3229, 3230, 7, 4, 0, 0, 3230, 3231, 7, 22, 0, 0, 3231, 3232, + 7, 9, 0, 0, 3232, 3233, 7, 8, 0, 0, 3233, 166, 1, 0, 0, 0, 3234, 3235, + 7, 0, 0, 0, 3235, 3236, 7, 24, 0, 0, 3236, 3237, 7, 17, 0, 0, 3237, 3238, + 7, 3, 0, 0, 3238, 3239, 7, 9, 0, 0, 3239, 168, 1, 0, 0, 0, 3240, 3241, + 7, 0, 0, 0, 3241, 3242, 7, 24, 0, 0, 3242, 3243, 7, 17, 0, 0, 3243, 3244, + 7, 3, 0, 0, 3244, 3245, 7, 9, 0, 0, 3245, 3246, 5, 95, 0, 0, 3246, 3247, + 7, 0, 0, 0, 3247, 3248, 7, 1, 0, 0, 3248, 3249, 5, 95, 0, 0, 3249, 3250, + 7, 0, 0, 0, 3250, 3251, 7, 2, 0, 0, 3251, 3252, 7, 2, 0, 0, 3252, 3253, + 7, 20, 0, 0, 3253, 3254, 7, 6, 0, 0, 3254, 3255, 7, 14, 0, 0, 3255, 3256, + 7, 0, 0, 0, 3256, 3257, 7, 11, 0, 0, 3257, 3258, 7, 6, 0, 0, 3258, 3259, + 7, 4, 0, 0, 3259, 3260, 7, 8, 0, 0, 3260, 3261, 5, 95, 0, 0, 3261, 3262, + 7, 6, 0, 0, 3262, 3263, 7, 1, 0, 0, 3263, 170, 1, 0, 0, 0, 3264, 3265, + 7, 0, 0, 0, 3265, 3266, 7, 24, 0, 0, 3266, 3267, 7, 17, 0, 0, 3267, 3268, + 7, 3, 0, 0, 3268, 3269, 7, 9, 0, 0, 3269, 3270, 5, 95, 0, 0, 3270, 3271, + 7, 9, 0, 0, 3271, 3272, 7, 5, 0, 0, 3272, 3273, 7, 9, 0, 0, 3273, 3274, + 7, 8, 0, 0, 3274, 3275, 7, 11, 0, 0, 3275, 3276, 5, 95, 0, 0, 3276, 3277, + 7, 21, 0, 0, 3277, 3278, 7, 3, 0, 0, 3278, 3279, 7, 6, 0, 0, 3279, 3280, + 7, 1, 0, 0, 3280, 172, 1, 0, 0, 0, 3281, 3282, 7, 0, 0, 0, 3282, 3283, + 7, 24, 0, 0, 3283, 3284, 7, 17, 0, 0, 3284, 3285, 7, 3, 0, 0, 3285, 3286, + 7, 9, 0, 0, 3286, 3287, 5, 95, 0, 0, 3287, 3288, 7, 9, 0, 0, 3288, 3289, + 7, 5, 0, 0, 3289, 3290, 7, 9, 0, 0, 3290, 3291, 7, 8, 0, 0, 3291, 3292, + 7, 11, 0, 0, 3292, 3293, 5, 95, 0, 0, 3293, 3294, 7, 21, 0, 0, 3294, 3295, + 7, 3, 0, 0, 3295, 3296, 7, 6, 0, 0, 3296, 3297, 7, 1, 0, 0, 3297, 3298, + 5, 95, 0, 0, 3298, 3299, 7, 11, 0, 0, 3299, 3300, 7, 4, 0, 0, 3300, 3301, + 7, 2, 0, 0, 3301, 3302, 7, 6, 0, 0, 3302, 3303, 7, 14, 0, 0, 3303, 3304, + 5, 95, 0, 0, 3304, 3305, 7, 9, 0, 0, 3305, 3306, 7, 8, 0, 0, 3306, 3307, + 7, 1, 0, 0, 3307, 3308, 7, 2, 0, 0, 3308, 3309, 7, 4, 0, 0, 3309, 3310, + 7, 6, 0, 0, 3310, 3311, 7, 8, 0, 0, 3311, 3312, 7, 11, 0, 0, 3312, 174, + 1, 0, 0, 0, 3313, 3314, 5, 39, 0, 0, 3314, 3315, 7, 0, 0, 0, 3315, 3316, + 7, 24, 0, 0, 3316, 3317, 7, 17, 0, 0, 3317, 3318, 7, 3, 0, 0, 3318, 3319, + 7, 9, 0, 0, 3319, 3320, 5, 39, 0, 0, 3320, 176, 1, 0, 0, 0, 3321, 3322, + 7, 0, 0, 0, 3322, 3323, 7, 24, 0, 0, 3323, 3324, 7, 17, 0, 0, 3324, 3325, + 7, 3, 0, 0, 3325, 3326, 7, 9, 0, 0, 3326, 3327, 5, 95, 0, 0, 3327, 3328, + 7, 7, 0, 0, 3328, 3329, 7, 0, 0, 0, 3329, 3330, 7, 7, 0, 0, 3330, 3331, + 5, 95, 0, 0, 3331, 3332, 7, 11, 0, 0, 3332, 3333, 7, 4, 0, 0, 3333, 3334, + 7, 22, 0, 0, 3334, 3335, 7, 9, 0, 0, 3335, 3336, 7, 8, 0, 0, 3336, 178, + 1, 0, 0, 0, 3337, 3338, 7, 0, 0, 0, 3338, 3339, 7, 24, 0, 0, 3339, 3340, + 7, 17, 0, 0, 3340, 3341, 7, 3, 0, 0, 3341, 3342, 7, 9, 0, 0, 3342, 3343, + 5, 95, 0, 0, 3343, 3344, 7, 7, 0, 0, 3344, 3345, 7, 11, 0, 0, 3345, 3346, + 7, 4, 0, 0, 3346, 3347, 7, 3, 0, 0, 3347, 3348, 7, 0, 0, 0, 3348, 3349, + 7, 21, 0, 0, 3349, 3350, 7, 9, 0, 0, 3350, 3351, 5, 95, 0, 0, 3351, 3352, + 7, 16, 0, 0, 3352, 3353, 7, 17, 0, 0, 3353, 3354, 7, 9, 0, 0, 3354, 3355, + 7, 17, 0, 0, 3355, 3356, 7, 9, 0, 0, 3356, 3357, 5, 95, 0, 0, 3357, 3358, + 7, 2, 0, 0, 3358, 3359, 7, 3, 0, 0, 3359, 3360, 7, 6, 0, 0, 3360, 3361, + 7, 19, 0, 0, 3361, 3362, 7, 0, 0, 0, 3362, 3363, 7, 3, 0, 0, 3363, 3364, + 7, 18, 0, 0, 3364, 3365, 5, 95, 0, 0, 3365, 3366, 7, 17, 0, 0, 3366, 3367, + 7, 3, 0, 0, 3367, 3368, 7, 6, 0, 0, 3368, 180, 1, 0, 0, 0, 3369, 3370, + 7, 0, 0, 0, 3370, 3371, 7, 24, 0, 0, 3371, 3372, 7, 17, 0, 0, 3372, 3373, + 7, 3, 0, 0, 3373, 3374, 7, 9, 0, 0, 3374, 3375, 5, 95, 0, 0, 3375, 3376, + 7, 11, 0, 0, 3376, 3377, 7, 9, 0, 0, 3377, 3378, 7, 8, 0, 0, 3378, 3379, + 7, 0, 0, 0, 3379, 3380, 7, 8, 0, 0, 3380, 3381, 7, 11, 0, 0, 3381, 3382, + 5, 95, 0, 0, 3382, 3383, 7, 6, 0, 0, 3383, 3384, 7, 1, 0, 0, 3384, 182, + 1, 0, 0, 0, 3385, 3386, 7, 10, 0, 0, 3386, 3387, 7, 0, 0, 0, 3387, 3388, + 7, 7, 0, 0, 3388, 3389, 7, 9, 0, 0, 3389, 3390, 5, 54, 0, 0, 3390, 3391, + 5, 52, 0, 0, 3391, 184, 1, 0, 0, 0, 3392, 3393, 7, 10, 0, 0, 3393, 3394, + 7, 9, 0, 0, 3394, 3395, 7, 12, 0, 0, 3395, 3396, 7, 4, 0, 0, 3396, 3397, + 7, 3, 0, 0, 3397, 3398, 7, 9, 0, 0, 3398, 186, 1, 0, 0, 0, 3399, 3400, + 7, 10, 0, 0, 3400, 3401, 7, 9, 0, 0, 3401, 3402, 7, 21, 0, 0, 3402, 3403, + 7, 6, 0, 0, 3403, 3404, 7, 8, 0, 0, 3404, 188, 1, 0, 0, 0, 3405, 3406, + 7, 10, 0, 0, 3406, 3407, 7, 9, 0, 0, 3407, 3408, 7, 3, 0, 0, 3408, 3409, + 7, 8, 0, 0, 3409, 3410, 7, 4, 0, 0, 3410, 3411, 7, 17, 0, 0, 3411, 3412, + 7, 20, 0, 0, 3412, 3413, 7, 20, 0, 0, 3413, 3414, 7, 6, 0, 0, 3414, 190, + 1, 0, 0, 0, 3415, 3416, 7, 10, 0, 0, 3416, 3417, 7, 9, 0, 0, 3417, 3418, + 7, 11, 0, 0, 3418, 3419, 7, 13, 0, 0, 3419, 3420, 7, 9, 0, 0, 3420, 3421, + 7, 9, 0, 0, 3421, 3422, 7, 8, 0, 0, 3422, 192, 1, 0, 0, 0, 3423, 3424, + 7, 10, 0, 0, 3424, 3425, 7, 6, 0, 0, 3425, 3426, 7, 8, 0, 0, 3426, 3427, + 7, 0, 0, 0, 3427, 3428, 7, 3, 0, 0, 3428, 3429, 7, 18, 0, 0, 3429, 3430, + 5, 95, 0, 0, 3430, 3431, 7, 0, 0, 0, 3431, 3432, 7, 7, 0, 0, 3432, 3433, + 5, 95, 0, 0, 3433, 3434, 7, 11, 0, 0, 3434, 3435, 7, 9, 0, 0, 3435, 3436, + 7, 23, 0, 0, 3436, 3437, 7, 11, 0, 0, 3437, 194, 1, 0, 0, 0, 3438, 3439, + 7, 10, 0, 0, 3439, 3440, 7, 6, 0, 0, 3440, 3441, 7, 8, 0, 0, 3441, 3442, + 7, 0, 0, 0, 3442, 3443, 7, 3, 0, 0, 3443, 3444, 7, 18, 0, 0, 3444, 3445, + 5, 95, 0, 0, 3445, 3446, 7, 14, 0, 0, 3446, 3447, 7, 15, 0, 0, 3447, 3448, + 7, 9, 0, 0, 3448, 3449, 7, 14, 0, 0, 3449, 3450, 7, 22, 0, 0, 3450, 3451, + 7, 7, 0, 0, 3451, 3452, 7, 17, 0, 0, 3452, 3453, 7, 19, 0, 0, 3453, 196, + 1, 0, 0, 0, 3454, 3455, 7, 10, 0, 0, 3455, 3456, 7, 6, 0, 0, 3456, 3457, + 7, 8, 0, 0, 3457, 3458, 7, 0, 0, 0, 3458, 3459, 7, 3, 0, 0, 3459, 3460, + 7, 18, 0, 0, 3460, 3461, 5, 95, 0, 0, 3461, 3462, 7, 12, 0, 0, 3462, 3463, + 7, 4, 0, 0, 3463, 3464, 7, 3, 0, 0, 3464, 3465, 7, 19, 0, 0, 3465, 3466, + 7, 0, 0, 0, 3466, 3467, 7, 11, 0, 0, 3467, 198, 1, 0, 0, 0, 3468, 3469, + 7, 10, 0, 0, 3469, 3470, 7, 6, 0, 0, 3470, 3471, 7, 8, 0, 0, 3471, 3472, + 7, 0, 0, 0, 3472, 3473, 7, 3, 0, 0, 3473, 3474, 7, 18, 0, 0, 3474, 3475, + 5, 95, 0, 0, 3475, 3476, 7, 6, 0, 0, 3476, 3477, 7, 8, 0, 0, 3477, 3478, + 7, 2, 0, 0, 3478, 3479, 7, 17, 0, 0, 3479, 3480, 7, 11, 0, 0, 3480, 3481, + 5, 95, 0, 0, 3481, 3482, 7, 12, 0, 0, 3482, 3483, 7, 4, 0, 0, 3483, 3484, + 7, 3, 0, 0, 3484, 3485, 7, 19, 0, 0, 3485, 3486, 7, 0, 0, 0, 3486, 3487, + 7, 11, 0, 0, 3487, 200, 1, 0, 0, 0, 3488, 3489, 7, 10, 0, 0, 3489, 3490, + 7, 6, 0, 0, 3490, 3491, 7, 8, 0, 0, 3491, 3492, 7, 0, 0, 0, 3492, 3493, + 7, 3, 0, 0, 3493, 3494, 7, 18, 0, 0, 3494, 3495, 5, 95, 0, 0, 3495, 3496, + 7, 4, 0, 0, 3496, 3497, 7, 17, 0, 0, 3497, 3498, 7, 11, 0, 0, 3498, 3499, + 7, 2, 0, 0, 3499, 3500, 7, 17, 0, 0, 3500, 3501, 7, 11, 0, 0, 3501, 3502, + 5, 95, 0, 0, 3502, 3503, 7, 12, 0, 0, 3503, 3504, 7, 4, 0, 0, 3504, 3505, + 7, 3, 0, 0, 3505, 3506, 7, 19, 0, 0, 3506, 3507, 7, 0, 0, 0, 3507, 3508, + 7, 11, 0, 0, 3508, 202, 1, 0, 0, 0, 3509, 3510, 7, 10, 0, 0, 3510, 3511, + 7, 6, 0, 0, 3511, 3512, 7, 8, 0, 0, 3512, 3513, 7, 1, 0, 0, 3513, 3514, + 7, 6, 0, 0, 3514, 3515, 7, 8, 0, 0, 3515, 3516, 7, 21, 0, 0, 3516, 204, + 1, 0, 0, 0, 3517, 3518, 7, 10, 0, 0, 3518, 3519, 7, 20, 0, 0, 3519, 3520, + 7, 4, 0, 0, 3520, 3521, 7, 14, 0, 0, 3521, 3522, 7, 22, 0, 0, 3522, 206, + 1, 0, 0, 0, 3523, 3524, 7, 10, 0, 0, 3524, 3525, 7, 20, 0, 0, 3525, 3526, + 7, 4, 0, 0, 3526, 3527, 7, 14, 0, 0, 3527, 3528, 7, 22, 0, 0, 3528, 3529, + 7, 9, 0, 0, 3529, 3530, 7, 1, 0, 0, 3530, 3531, 5, 95, 0, 0, 3531, 3532, + 7, 6, 0, 0, 3532, 3533, 7, 2, 0, 0, 3533, 3534, 5, 95, 0, 0, 3534, 3535, + 7, 20, 0, 0, 3535, 3536, 7, 6, 0, 0, 3536, 3537, 7, 7, 0, 0, 3537, 3538, + 7, 11, 0, 0, 3538, 208, 1, 0, 0, 0, 3539, 3540, 7, 10, 0, 0, 3540, 3541, + 7, 20, 0, 0, 3541, 3542, 7, 4, 0, 0, 3542, 3543, 7, 14, 0, 0, 3543, 3544, + 7, 22, 0, 0, 3544, 3545, 7, 9, 0, 0, 3545, 3546, 7, 1, 0, 0, 3546, 3547, + 5, 95, 0, 0, 3547, 3548, 7, 3, 0, 0, 3548, 3549, 7, 4, 0, 0, 3549, 3550, + 7, 20, 0, 0, 3550, 3551, 7, 9, 0, 0, 3551, 3552, 7, 7, 0, 0, 3552, 3553, + 5, 95, 0, 0, 3553, 3554, 7, 20, 0, 0, 3554, 3555, 7, 6, 0, 0, 3555, 3556, + 7, 7, 0, 0, 3556, 3557, 7, 11, 0, 0, 3557, 210, 1, 0, 0, 0, 3558, 3559, + 7, 10, 0, 0, 3559, 3560, 7, 4, 0, 0, 3560, 3561, 7, 1, 0, 0, 3561, 3562, + 7, 18, 0, 0, 3562, 212, 1, 0, 0, 0, 3563, 3564, 5, 39, 0, 0, 3564, 3565, + 7, 10, 0, 0, 3565, 3566, 7, 4, 0, 0, 3566, 3567, 7, 11, 0, 0, 3567, 3568, + 7, 15, 0, 0, 3568, 3569, 5, 39, 0, 0, 3569, 214, 1, 0, 0, 0, 3570, 3571, + 7, 10, 0, 0, 3571, 3572, 7, 3, 0, 0, 3572, 3573, 7, 4, 0, 0, 3573, 3574, + 7, 11, 0, 0, 3574, 3575, 7, 20, 0, 0, 3575, 3576, 7, 6, 0, 0, 3576, 216, + 1, 0, 0, 0, 3577, 3578, 7, 10, 0, 0, 3578, 3579, 7, 17, 0, 0, 3579, 3580, + 7, 7, 0, 0, 3580, 3581, 7, 6, 0, 0, 3581, 3582, 7, 8, 0, 0, 3582, 3583, + 7, 9, 0, 0, 3583, 3584, 7, 7, 0, 0, 3584, 3585, 7, 7, 0, 0, 3585, 3586, + 5, 95, 0, 0, 3586, 3587, 7, 14, 0, 0, 3587, 3588, 7, 3, 0, 0, 3588, 3589, + 7, 6, 0, 0, 3589, 3590, 7, 11, 0, 0, 3590, 3591, 7, 6, 0, 0, 3591, 3592, + 7, 14, 0, 0, 3592, 3593, 7, 0, 0, 0, 3593, 3594, 7, 20, 0, 0, 3594, 218, + 1, 0, 0, 0, 3595, 3596, 7, 10, 0, 0, 3596, 3597, 7, 18, 0, 0, 3597, 220, + 1, 0, 0, 0, 3598, 3599, 7, 10, 0, 0, 3599, 3600, 7, 24, 0, 0, 3600, 3601, + 5, 50, 0, 0, 3601, 222, 1, 0, 0, 0, 3602, 3603, 7, 14, 0, 0, 3603, 3604, + 7, 0, 0, 0, 3604, 3605, 7, 14, 0, 0, 3605, 3606, 7, 15, 0, 0, 3606, 3607, + 7, 9, 0, 0, 3607, 224, 1, 0, 0, 0, 3608, 3609, 7, 14, 0, 0, 3609, 3610, + 7, 0, 0, 0, 3610, 3611, 7, 20, 0, 0, 3611, 3612, 7, 20, 0, 0, 3612, 226, + 1, 0, 0, 0, 3613, 3614, 7, 14, 0, 0, 3614, 3615, 7, 0, 0, 0, 3615, 3616, + 7, 20, 0, 0, 3616, 3617, 7, 20, 0, 0, 3617, 3618, 7, 9, 0, 0, 3618, 3619, + 7, 1, 0, 0, 3619, 228, 1, 0, 0, 0, 3620, 3621, 7, 14, 0, 0, 3621, 3622, + 7, 0, 0, 0, 3622, 3623, 7, 20, 0, 0, 3623, 3624, 7, 20, 0, 0, 3624, 3625, + 7, 9, 0, 0, 3625, 3626, 7, 3, 0, 0, 3626, 230, 1, 0, 0, 0, 3627, 3628, + 7, 14, 0, 0, 3628, 3629, 7, 0, 0, 0, 3629, 3630, 7, 7, 0, 0, 3630, 3631, + 7, 14, 0, 0, 3631, 3632, 7, 0, 0, 0, 3632, 3633, 7, 1, 0, 0, 3633, 3634, + 7, 9, 0, 0, 3634, 232, 1, 0, 0, 0, 3635, 3636, 7, 14, 0, 0, 3636, 3637, + 7, 0, 0, 0, 3637, 3638, 7, 7, 0, 0, 3638, 3639, 7, 9, 0, 0, 3639, 234, + 1, 0, 0, 0, 3640, 3641, 7, 14, 0, 0, 3641, 3642, 7, 0, 0, 0, 3642, 3643, + 7, 7, 0, 0, 3643, 3644, 7, 9, 0, 0, 3644, 3645, 5, 95, 0, 0, 3645, 3646, + 7, 6, 0, 0, 3646, 3647, 7, 8, 0, 0, 3647, 3648, 7, 7, 0, 0, 3648, 3649, + 7, 9, 0, 0, 3649, 3650, 7, 8, 0, 0, 3650, 3651, 7, 7, 0, 0, 3651, 3652, + 7, 6, 0, 0, 3652, 3653, 7, 11, 0, 0, 3653, 3654, 7, 6, 0, 0, 3654, 3655, + 7, 5, 0, 0, 3655, 3656, 7, 9, 0, 0, 3656, 236, 1, 0, 0, 0, 3657, 3658, + 7, 14, 0, 0, 3658, 3659, 7, 0, 0, 0, 3659, 3660, 7, 7, 0, 0, 3660, 3661, + 7, 9, 0, 0, 3661, 3662, 5, 95, 0, 0, 3662, 3663, 7, 7, 0, 0, 3663, 3664, + 7, 9, 0, 0, 3664, 3665, 7, 8, 0, 0, 3665, 3666, 7, 7, 0, 0, 3666, 3667, + 7, 6, 0, 0, 3667, 3668, 7, 11, 0, 0, 3668, 3669, 7, 6, 0, 0, 3669, 3670, + 7, 5, 0, 0, 3670, 3671, 7, 9, 0, 0, 3671, 238, 1, 0, 0, 0, 3672, 3673, + 7, 14, 0, 0, 3673, 3674, 7, 0, 0, 0, 3674, 3675, 7, 7, 0, 0, 3675, 3676, + 7, 11, 0, 0, 3676, 240, 1, 0, 0, 0, 3677, 3678, 7, 14, 0, 0, 3678, 3679, + 7, 0, 0, 0, 3679, 3680, 7, 11, 0, 0, 3680, 3681, 7, 14, 0, 0, 3681, 3682, + 7, 15, 0, 0, 3682, 242, 1, 0, 0, 0, 3683, 3684, 7, 14, 0, 0, 3684, 3685, + 7, 9, 0, 0, 3685, 3686, 7, 3, 0, 0, 3686, 3687, 7, 11, 0, 0, 3687, 3688, + 7, 6, 0, 0, 3688, 3689, 7, 12, 0, 0, 3689, 3690, 7, 6, 0, 0, 3690, 3691, + 7, 14, 0, 0, 3691, 3692, 7, 0, 0, 0, 3692, 3693, 7, 11, 0, 0, 3693, 3694, + 7, 9, 0, 0, 3694, 244, 1, 0, 0, 0, 3695, 3696, 7, 14, 0, 0, 3696, 3697, + 7, 15, 0, 0, 3697, 3698, 7, 0, 0, 0, 3698, 3699, 7, 8, 0, 0, 3699, 3700, + 7, 21, 0, 0, 3700, 3701, 7, 9, 0, 0, 3701, 246, 1, 0, 0, 0, 3702, 3703, + 7, 14, 0, 0, 3703, 3704, 7, 15, 0, 0, 3704, 3705, 7, 0, 0, 0, 3705, 3706, + 7, 8, 0, 0, 3706, 3707, 7, 21, 0, 0, 3707, 3708, 7, 9, 0, 0, 3708, 3709, + 7, 7, 0, 0, 3709, 248, 1, 0, 0, 0, 3710, 3711, 7, 14, 0, 0, 3711, 3712, + 7, 15, 0, 0, 3712, 3713, 7, 0, 0, 0, 3713, 3714, 7, 8, 0, 0, 3714, 3715, + 7, 21, 0, 0, 3715, 3716, 7, 9, 0, 0, 3716, 3717, 7, 11, 0, 0, 3717, 3718, + 7, 0, 0, 0, 3718, 3719, 7, 10, 0, 0, 3719, 3720, 7, 20, 0, 0, 3720, 3721, + 7, 9, 0, 0, 3721, 250, 1, 0, 0, 0, 3722, 3723, 7, 14, 0, 0, 3723, 3724, + 7, 15, 0, 0, 3724, 3725, 7, 0, 0, 0, 3725, 3726, 7, 8, 0, 0, 3726, 3727, + 7, 21, 0, 0, 3727, 3728, 7, 9, 0, 0, 3728, 3729, 5, 95, 0, 0, 3729, 3730, + 7, 3, 0, 0, 3730, 3731, 7, 9, 0, 0, 3731, 3732, 7, 11, 0, 0, 3732, 3733, + 7, 9, 0, 0, 3733, 3734, 7, 8, 0, 0, 3734, 3735, 7, 11, 0, 0, 3735, 3736, + 7, 6, 0, 0, 3736, 3737, 7, 4, 0, 0, 3737, 3738, 7, 8, 0, 0, 3738, 252, + 1, 0, 0, 0, 3739, 3740, 7, 14, 0, 0, 3740, 3741, 7, 15, 0, 0, 3741, 3742, + 7, 0, 0, 0, 3742, 3743, 7, 8, 0, 0, 3743, 3744, 7, 21, 0, 0, 3744, 3745, + 7, 9, 0, 0, 3745, 3746, 5, 95, 0, 0, 3746, 3747, 7, 11, 0, 0, 3747, 3748, + 7, 3, 0, 0, 3748, 3749, 7, 0, 0, 0, 3749, 3750, 7, 14, 0, 0, 3750, 3751, + 7, 22, 0, 0, 3751, 3752, 7, 6, 0, 0, 3752, 3753, 7, 8, 0, 0, 3753, 3754, + 7, 21, 0, 0, 3754, 254, 1, 0, 0, 0, 3755, 3756, 7, 14, 0, 0, 3756, 3757, + 7, 15, 0, 0, 3757, 3758, 7, 0, 0, 0, 3758, 3759, 7, 3, 0, 0, 3759, 256, + 1, 0, 0, 0, 3760, 3761, 7, 14, 0, 0, 3761, 3762, 7, 15, 0, 0, 3762, 3763, + 7, 0, 0, 0, 3763, 3764, 7, 3, 0, 0, 3764, 3765, 7, 0, 0, 0, 3765, 3766, + 7, 14, 0, 0, 3766, 3767, 7, 11, 0, 0, 3767, 3768, 7, 9, 0, 0, 3768, 3769, + 7, 3, 0, 0, 3769, 258, 1, 0, 0, 0, 3770, 3771, 7, 14, 0, 0, 3771, 3772, + 7, 15, 0, 0, 3772, 3773, 7, 0, 0, 0, 3773, 3774, 7, 3, 0, 0, 3774, 3775, + 7, 6, 0, 0, 3775, 3776, 7, 8, 0, 0, 3776, 3777, 7, 1, 0, 0, 3777, 3778, + 7, 9, 0, 0, 3778, 3779, 7, 23, 0, 0, 3779, 260, 1, 0, 0, 0, 3780, 3781, + 7, 14, 0, 0, 3781, 3782, 7, 15, 0, 0, 3782, 3783, 7, 9, 0, 0, 3783, 3784, + 7, 14, 0, 0, 3784, 3785, 7, 22, 0, 0, 3785, 262, 1, 0, 0, 0, 3786, 3787, + 7, 14, 0, 0, 3787, 3788, 7, 15, 0, 0, 3788, 3789, 7, 9, 0, 0, 3789, 3790, + 7, 14, 0, 0, 3790, 3791, 7, 22, 0, 0, 3791, 3792, 7, 7, 0, 0, 3792, 3793, + 7, 17, 0, 0, 3793, 3794, 7, 19, 0, 0, 3794, 264, 1, 0, 0, 0, 3795, 3796, + 7, 14, 0, 0, 3796, 3797, 7, 15, 0, 0, 3797, 3798, 7, 9, 0, 0, 3798, 3799, + 7, 14, 0, 0, 3799, 3800, 7, 22, 0, 0, 3800, 3801, 7, 7, 0, 0, 3801, 3802, + 7, 17, 0, 0, 3802, 3803, 7, 19, 0, 0, 3803, 3804, 5, 95, 0, 0, 3804, 3805, + 7, 0, 0, 0, 3805, 3806, 7, 21, 0, 0, 3806, 3807, 7, 21, 0, 0, 3807, 266, + 1, 0, 0, 0, 3808, 3809, 7, 14, 0, 0, 3809, 3810, 7, 15, 0, 0, 3810, 3811, + 7, 9, 0, 0, 3811, 3812, 7, 14, 0, 0, 3812, 3813, 7, 22, 0, 0, 3813, 3814, + 5, 95, 0, 0, 3814, 3815, 7, 9, 0, 0, 3815, 3816, 7, 23, 0, 0, 3816, 3817, + 7, 2, 0, 0, 3817, 3818, 7, 6, 0, 0, 3818, 3819, 7, 3, 0, 0, 3819, 3820, + 7, 0, 0, 0, 3820, 3821, 7, 11, 0, 0, 3821, 3822, 7, 6, 0, 0, 3822, 3823, + 7, 4, 0, 0, 3823, 3824, 7, 8, 0, 0, 3824, 268, 1, 0, 0, 0, 3825, 3826, + 7, 14, 0, 0, 3826, 3827, 7, 15, 0, 0, 3827, 3828, 7, 9, 0, 0, 3828, 3829, + 7, 14, 0, 0, 3829, 3830, 7, 22, 0, 0, 3830, 3831, 5, 95, 0, 0, 3831, 3832, + 7, 2, 0, 0, 3832, 3833, 7, 4, 0, 0, 3833, 3834, 7, 20, 0, 0, 3834, 3835, + 7, 6, 0, 0, 3835, 3836, 7, 14, 0, 0, 3836, 3837, 7, 18, 0, 0, 3837, 270, + 1, 0, 0, 0, 3838, 3839, 7, 14, 0, 0, 3839, 3840, 7, 20, 0, 0, 3840, 3841, + 7, 0, 0, 0, 3841, 3842, 7, 7, 0, 0, 3842, 3843, 7, 7, 0, 0, 3843, 3844, + 7, 6, 0, 0, 3844, 3845, 7, 12, 0, 0, 3845, 3846, 7, 6, 0, 0, 3846, 3847, + 7, 9, 0, 0, 3847, 3848, 7, 3, 0, 0, 3848, 3849, 5, 95, 0, 0, 3849, 3850, + 7, 12, 0, 0, 3850, 3851, 7, 17, 0, 0, 3851, 3852, 7, 8, 0, 0, 3852, 3853, + 7, 14, 0, 0, 3853, 3854, 7, 11, 0, 0, 3854, 3855, 7, 6, 0, 0, 3855, 3856, + 7, 4, 0, 0, 3856, 3857, 7, 8, 0, 0, 3857, 272, 1, 0, 0, 0, 3858, 3859, + 7, 14, 0, 0, 3859, 3860, 7, 20, 0, 0, 3860, 3861, 7, 9, 0, 0, 3861, 3862, + 7, 0, 0, 0, 3862, 3863, 7, 8, 0, 0, 3863, 3864, 7, 17, 0, 0, 3864, 3865, + 7, 2, 0, 0, 3865, 274, 1, 0, 0, 0, 3866, 3867, 7, 14, 0, 0, 3867, 3868, + 7, 20, 0, 0, 3868, 3869, 7, 6, 0, 0, 3869, 3870, 7, 9, 0, 0, 3870, 3871, + 7, 8, 0, 0, 3871, 3872, 7, 11, 0, 0, 3872, 3873, 5, 95, 0, 0, 3873, 3874, + 7, 9, 0, 0, 3874, 3875, 7, 8, 0, 0, 3875, 3876, 7, 0, 0, 0, 3876, 3877, + 7, 10, 0, 0, 3877, 3878, 7, 20, 0, 0, 3878, 3879, 7, 9, 0, 0, 3879, 3880, + 5, 95, 0, 0, 3880, 3881, 7, 20, 0, 0, 3881, 3882, 7, 4, 0, 0, 3882, 3883, + 7, 21, 0, 0, 3883, 3884, 5, 95, 0, 0, 3884, 3885, 7, 6, 0, 0, 3885, 3886, + 7, 8, 0, 0, 3886, 3887, 7, 12, 0, 0, 3887, 3888, 7, 4, 0, 0, 3888, 3889, + 5, 95, 0, 0, 3889, 3890, 7, 7, 0, 0, 3890, 3891, 7, 11, 0, 0, 3891, 3892, + 7, 0, 0, 0, 3892, 3893, 7, 11, 0, 0, 3893, 3894, 7, 9, 0, 0, 3894, 3895, + 7, 19, 0, 0, 3895, 3896, 7, 9, 0, 0, 3896, 3897, 7, 8, 0, 0, 3897, 3898, + 7, 11, 0, 0, 3898, 3899, 5, 95, 0, 0, 3899, 3900, 7, 2, 0, 0, 3900, 3901, + 7, 0, 0, 0, 3901, 3902, 7, 3, 0, 0, 3902, 3903, 7, 0, 0, 0, 3903, 3904, + 7, 19, 0, 0, 3904, 3905, 7, 9, 0, 0, 3905, 3906, 7, 11, 0, 0, 3906, 3907, + 7, 9, 0, 0, 3907, 3908, 7, 3, 0, 0, 3908, 3909, 7, 7, 0, 0, 3909, 276, + 1, 0, 0, 0, 3910, 3911, 7, 14, 0, 0, 3911, 3912, 7, 20, 0, 0, 3912, 3913, + 7, 6, 0, 0, 3913, 3914, 7, 9, 0, 0, 3914, 3915, 7, 8, 0, 0, 3915, 3916, + 7, 11, 0, 0, 3916, 3917, 5, 95, 0, 0, 3917, 3918, 7, 9, 0, 0, 3918, 3919, + 7, 8, 0, 0, 3919, 3920, 7, 14, 0, 0, 3920, 3921, 7, 3, 0, 0, 3921, 3922, + 7, 18, 0, 0, 3922, 3923, 7, 2, 0, 0, 3923, 3924, 7, 11, 0, 0, 3924, 3925, + 7, 6, 0, 0, 3925, 3926, 7, 4, 0, 0, 3926, 3927, 7, 8, 0, 0, 3927, 3928, + 5, 95, 0, 0, 3928, 3929, 7, 22, 0, 0, 3929, 3930, 7, 9, 0, 0, 3930, 3931, + 7, 18, 0, 0, 3931, 3932, 5, 95, 0, 0, 3932, 3933, 7, 7, 0, 0, 3933, 3934, + 7, 6, 0, 0, 3934, 3935, 7, 24, 0, 0, 3935, 3936, 7, 9, 0, 0, 3936, 278, + 1, 0, 0, 0, 3937, 3938, 7, 14, 0, 0, 3938, 3939, 7, 20, 0, 0, 3939, 3940, + 7, 6, 0, 0, 3940, 3941, 7, 9, 0, 0, 3941, 3942, 7, 8, 0, 0, 3942, 3943, + 7, 11, 0, 0, 3943, 3944, 5, 95, 0, 0, 3944, 3945, 7, 19, 0, 0, 3945, 3946, + 7, 9, 0, 0, 3946, 3947, 7, 19, 0, 0, 3947, 3948, 7, 4, 0, 0, 3948, 3949, + 7, 3, 0, 0, 3949, 3950, 7, 18, 0, 0, 3950, 3951, 5, 95, 0, 0, 3951, 3952, + 7, 20, 0, 0, 3952, 3953, 7, 6, 0, 0, 3953, 3954, 7, 19, 0, 0, 3954, 3955, + 7, 6, 0, 0, 3955, 3956, 7, 11, 0, 0, 3956, 280, 1, 0, 0, 0, 3957, 3958, + 7, 14, 0, 0, 3958, 3959, 7, 20, 0, 0, 3959, 3960, 7, 6, 0, 0, 3960, 3961, + 7, 9, 0, 0, 3961, 3962, 7, 8, 0, 0, 3962, 3963, 7, 11, 0, 0, 3963, 3964, + 5, 95, 0, 0, 3964, 3965, 7, 19, 0, 0, 3965, 3966, 7, 9, 0, 0, 3966, 3967, + 7, 11, 0, 0, 3967, 3968, 7, 0, 0, 0, 3968, 3969, 7, 1, 0, 0, 3969, 3970, + 7, 0, 0, 0, 3970, 3971, 7, 11, 0, 0, 3971, 3972, 7, 0, 0, 0, 3972, 3973, + 5, 95, 0, 0, 3973, 3974, 7, 3, 0, 0, 3974, 3975, 7, 9, 0, 0, 3975, 3976, + 7, 16, 0, 0, 3976, 3977, 7, 17, 0, 0, 3977, 3978, 7, 9, 0, 0, 3978, 3979, + 7, 7, 0, 0, 3979, 3980, 7, 11, 0, 0, 3980, 3981, 5, 95, 0, 0, 3981, 3982, + 7, 17, 0, 0, 3982, 3983, 7, 7, 0, 0, 3983, 3984, 7, 9, 0, 0, 3984, 3985, + 5, 95, 0, 0, 3985, 3986, 7, 14, 0, 0, 3986, 3987, 7, 4, 0, 0, 3987, 3988, + 7, 8, 0, 0, 3988, 3989, 7, 8, 0, 0, 3989, 3990, 7, 9, 0, 0, 3990, 3991, + 7, 14, 0, 0, 3991, 3992, 7, 11, 0, 0, 3992, 3993, 7, 6, 0, 0, 3993, 3994, + 7, 4, 0, 0, 3994, 3995, 7, 8, 0, 0, 3995, 3996, 5, 95, 0, 0, 3996, 3997, + 7, 14, 0, 0, 3997, 3998, 7, 11, 0, 0, 3998, 3999, 7, 23, 0, 0, 3999, 282, + 1, 0, 0, 0, 4000, 4001, 7, 14, 0, 0, 4001, 4002, 7, 20, 0, 0, 4002, 4003, + 7, 6, 0, 0, 4003, 4004, 7, 9, 0, 0, 4004, 4005, 7, 8, 0, 0, 4005, 4006, + 7, 11, 0, 0, 4006, 4007, 5, 95, 0, 0, 4007, 4008, 7, 19, 0, 0, 4008, 4009, + 7, 9, 0, 0, 4009, 4010, 7, 11, 0, 0, 4010, 4011, 7, 0, 0, 0, 4011, 4012, + 7, 1, 0, 0, 4012, 4013, 7, 0, 0, 0, 4013, 4014, 7, 11, 0, 0, 4014, 4015, + 7, 0, 0, 0, 4015, 4016, 5, 95, 0, 0, 4016, 4017, 7, 17, 0, 0, 4017, 4018, + 7, 7, 0, 0, 4018, 4019, 7, 9, 0, 0, 4019, 4020, 5, 95, 0, 0, 4020, 4021, + 7, 7, 0, 0, 4021, 4022, 7, 9, 0, 0, 4022, 4023, 7, 7, 0, 0, 4023, 4024, + 7, 7, 0, 0, 4024, 4025, 7, 6, 0, 0, 4025, 4026, 7, 4, 0, 0, 4026, 4027, + 7, 8, 0, 0, 4027, 4028, 5, 95, 0, 0, 4028, 4029, 7, 1, 0, 0, 4029, 4030, + 7, 0, 0, 0, 4030, 4031, 7, 11, 0, 0, 4031, 4032, 7, 0, 0, 0, 4032, 4033, + 7, 10, 0, 0, 4033, 4034, 7, 0, 0, 0, 4034, 4035, 7, 7, 0, 0, 4035, 4036, + 7, 9, 0, 0, 4036, 284, 1, 0, 0, 0, 4037, 4038, 7, 14, 0, 0, 4038, 4039, + 7, 20, 0, 0, 4039, 4040, 7, 6, 0, 0, 4040, 4041, 7, 9, 0, 0, 4041, 4042, + 7, 8, 0, 0, 4042, 4043, 7, 11, 0, 0, 4043, 4044, 5, 95, 0, 0, 4044, 4045, + 7, 2, 0, 0, 4045, 4046, 7, 3, 0, 0, 4046, 4047, 7, 9, 0, 0, 4047, 4048, + 7, 12, 0, 0, 4048, 4049, 7, 9, 0, 0, 4049, 4050, 7, 11, 0, 0, 4050, 4051, + 7, 14, 0, 0, 4051, 4052, 7, 15, 0, 0, 4052, 4053, 5, 95, 0, 0, 4053, 4054, + 7, 11, 0, 0, 4054, 4055, 7, 15, 0, 0, 4055, 4056, 7, 3, 0, 0, 4056, 4057, + 7, 9, 0, 0, 4057, 4058, 7, 0, 0, 0, 4058, 4059, 7, 1, 0, 0, 4059, 4060, + 7, 7, 0, 0, 4060, 286, 1, 0, 0, 0, 4061, 4062, 7, 14, 0, 0, 4062, 4063, + 7, 20, 0, 0, 4063, 4064, 7, 6, 0, 0, 4064, 4065, 7, 9, 0, 0, 4065, 4066, + 7, 8, 0, 0, 4066, 4067, 7, 11, 0, 0, 4067, 4068, 5, 95, 0, 0, 4068, 4069, + 7, 3, 0, 0, 4069, 4070, 7, 9, 0, 0, 4070, 4071, 7, 7, 0, 0, 4071, 4072, + 7, 17, 0, 0, 4072, 4073, 7, 20, 0, 0, 4073, 4074, 7, 11, 0, 0, 4074, 4075, + 5, 95, 0, 0, 4075, 4076, 7, 14, 0, 0, 4076, 4077, 7, 15, 0, 0, 4077, 4078, + 7, 17, 0, 0, 4078, 4079, 7, 8, 0, 0, 4079, 4080, 7, 22, 0, 0, 4080, 4081, + 5, 95, 0, 0, 4081, 4082, 7, 7, 0, 0, 4082, 4083, 7, 6, 0, 0, 4083, 4084, + 7, 24, 0, 0, 4084, 4085, 7, 9, 0, 0, 4085, 288, 1, 0, 0, 0, 4086, 4087, + 7, 14, 0, 0, 4087, 4088, 7, 20, 0, 0, 4088, 4089, 7, 6, 0, 0, 4089, 4090, + 7, 9, 0, 0, 4090, 4091, 7, 8, 0, 0, 4091, 4092, 7, 11, 0, 0, 4092, 4093, + 5, 95, 0, 0, 4093, 4094, 7, 3, 0, 0, 4094, 4095, 7, 9, 0, 0, 4095, 4096, + 7, 7, 0, 0, 4096, 4097, 7, 17, 0, 0, 4097, 4098, 7, 20, 0, 0, 4098, 4099, + 7, 11, 0, 0, 4099, 4100, 5, 95, 0, 0, 4100, 4101, 7, 14, 0, 0, 4101, 4102, + 7, 4, 0, 0, 4102, 4103, 7, 20, 0, 0, 4103, 4104, 7, 17, 0, 0, 4104, 4105, + 7, 19, 0, 0, 4105, 4106, 7, 8, 0, 0, 4106, 4107, 5, 95, 0, 0, 4107, 4108, + 7, 14, 0, 0, 4108, 4109, 7, 0, 0, 0, 4109, 4110, 7, 7, 0, 0, 4110, 4111, + 7, 9, 0, 0, 4111, 4112, 5, 95, 0, 0, 4112, 4113, 7, 6, 0, 0, 4113, 4114, + 7, 8, 0, 0, 4114, 4115, 7, 7, 0, 0, 4115, 4116, 7, 9, 0, 0, 4116, 4117, + 7, 8, 0, 0, 4117, 4118, 7, 7, 0, 0, 4118, 4119, 7, 6, 0, 0, 4119, 4120, + 7, 11, 0, 0, 4120, 4121, 7, 6, 0, 0, 4121, 4122, 7, 5, 0, 0, 4122, 4123, + 7, 9, 0, 0, 4123, 290, 1, 0, 0, 0, 4124, 4125, 7, 14, 0, 0, 4125, 4126, + 7, 20, 0, 0, 4126, 4127, 7, 6, 0, 0, 4127, 4128, 7, 9, 0, 0, 4128, 4129, + 7, 8, 0, 0, 4129, 4130, 7, 11, 0, 0, 4130, 4131, 5, 95, 0, 0, 4131, 4132, + 7, 7, 0, 0, 4132, 4133, 7, 9, 0, 0, 4133, 4134, 7, 7, 0, 0, 4134, 4135, + 7, 7, 0, 0, 4135, 4136, 7, 6, 0, 0, 4136, 4137, 7, 4, 0, 0, 4137, 4138, + 7, 8, 0, 0, 4138, 4139, 5, 95, 0, 0, 4139, 4140, 7, 22, 0, 0, 4140, 4141, + 7, 9, 0, 0, 4141, 4142, 7, 9, 0, 0, 4142, 4143, 7, 2, 0, 0, 4143, 4144, + 5, 95, 0, 0, 4144, 4145, 7, 0, 0, 0, 4145, 4146, 7, 20, 0, 0, 4146, 4147, + 7, 6, 0, 0, 4147, 4148, 7, 5, 0, 0, 4148, 4149, 7, 9, 0, 0, 4149, 292, + 1, 0, 0, 0, 4150, 4151, 7, 14, 0, 0, 4151, 4152, 7, 20, 0, 0, 4152, 4153, + 7, 6, 0, 0, 4153, 4154, 7, 9, 0, 0, 4154, 4155, 7, 8, 0, 0, 4155, 4156, + 7, 11, 0, 0, 4156, 4157, 5, 95, 0, 0, 4157, 4158, 7, 7, 0, 0, 4158, 4159, + 7, 9, 0, 0, 4159, 4160, 7, 7, 0, 0, 4160, 4161, 7, 7, 0, 0, 4161, 4162, + 7, 6, 0, 0, 4162, 4163, 7, 4, 0, 0, 4163, 4164, 7, 8, 0, 0, 4164, 4165, + 5, 95, 0, 0, 4165, 4166, 7, 22, 0, 0, 4166, 4167, 7, 9, 0, 0, 4167, 4168, + 7, 9, 0, 0, 4168, 4169, 7, 2, 0, 0, 4169, 4170, 5, 95, 0, 0, 4170, 4171, + 7, 0, 0, 0, 4171, 4172, 7, 20, 0, 0, 4172, 4173, 7, 6, 0, 0, 4173, 4174, + 7, 5, 0, 0, 4174, 4175, 7, 9, 0, 0, 4175, 4176, 5, 95, 0, 0, 4176, 4177, + 7, 15, 0, 0, 4177, 4178, 7, 9, 0, 0, 4178, 4179, 7, 0, 0, 0, 4179, 4180, + 7, 3, 0, 0, 4180, 4181, 7, 11, 0, 0, 4181, 4182, 7, 10, 0, 0, 4182, 4183, + 7, 9, 0, 0, 4183, 4184, 7, 0, 0, 0, 4184, 4185, 7, 11, 0, 0, 4185, 4186, + 5, 95, 0, 0, 4186, 4187, 7, 12, 0, 0, 4187, 4188, 7, 3, 0, 0, 4188, 4189, + 7, 9, 0, 0, 4189, 4190, 7, 16, 0, 0, 4190, 4191, 7, 17, 0, 0, 4191, 4192, + 7, 9, 0, 0, 4192, 4193, 7, 8, 0, 0, 4193, 4194, 7, 14, 0, 0, 4194, 4195, + 7, 18, 0, 0, 4195, 294, 1, 0, 0, 0, 4196, 4197, 7, 14, 0, 0, 4197, 4198, + 7, 20, 0, 0, 4198, 4199, 7, 6, 0, 0, 4199, 4200, 7, 9, 0, 0, 4200, 4201, + 7, 8, 0, 0, 4201, 4202, 7, 11, 0, 0, 4202, 4203, 5, 95, 0, 0, 4203, 4204, + 7, 11, 0, 0, 4204, 4205, 7, 6, 0, 0, 4205, 4206, 7, 19, 0, 0, 4206, 4207, + 7, 9, 0, 0, 4207, 4208, 7, 7, 0, 0, 4208, 4209, 7, 11, 0, 0, 4209, 4210, + 7, 0, 0, 0, 4210, 4211, 7, 19, 0, 0, 4211, 4212, 7, 2, 0, 0, 4212, 4213, + 5, 95, 0, 0, 4213, 4214, 7, 11, 0, 0, 4214, 4215, 7, 18, 0, 0, 4215, 4216, + 7, 2, 0, 0, 4216, 4217, 7, 9, 0, 0, 4217, 4218, 5, 95, 0, 0, 4218, 4219, + 7, 19, 0, 0, 4219, 4220, 7, 0, 0, 0, 4220, 4221, 7, 2, 0, 0, 4221, 4222, + 7, 2, 0, 0, 4222, 4223, 7, 6, 0, 0, 4223, 4224, 7, 8, 0, 0, 4224, 4225, + 7, 21, 0, 0, 4225, 296, 1, 0, 0, 0, 4226, 4227, 7, 14, 0, 0, 4227, 4228, + 7, 20, 0, 0, 4228, 4229, 7, 4, 0, 0, 4229, 4230, 7, 8, 0, 0, 4230, 4231, + 7, 9, 0, 0, 4231, 298, 1, 0, 0, 0, 4232, 4233, 7, 14, 0, 0, 4233, 4234, + 7, 20, 0, 0, 4234, 4235, 7, 4, 0, 0, 4235, 4236, 7, 7, 0, 0, 4236, 4237, + 7, 9, 0, 0, 4237, 300, 1, 0, 0, 0, 4238, 4239, 7, 14, 0, 0, 4239, 4240, + 7, 20, 0, 0, 4240, 4241, 7, 17, 0, 0, 4241, 4242, 7, 7, 0, 0, 4242, 4243, + 7, 11, 0, 0, 4243, 4244, 7, 9, 0, 0, 4244, 4245, 7, 3, 0, 0, 4245, 302, + 1, 0, 0, 0, 4246, 4247, 7, 14, 0, 0, 4247, 4248, 7, 20, 0, 0, 4248, 4249, + 7, 17, 0, 0, 4249, 4250, 7, 7, 0, 0, 4250, 4251, 7, 11, 0, 0, 4251, 4252, + 7, 9, 0, 0, 4252, 4253, 7, 3, 0, 0, 4253, 4254, 7, 9, 0, 0, 4254, 4255, + 7, 1, 0, 0, 4255, 304, 1, 0, 0, 0, 4256, 4257, 7, 14, 0, 0, 4257, 4258, + 7, 20, 0, 0, 4258, 4259, 7, 17, 0, 0, 4259, 4260, 7, 7, 0, 0, 4260, 4261, + 7, 11, 0, 0, 4261, 4262, 7, 9, 0, 0, 4262, 4263, 7, 3, 0, 0, 4263, 4264, + 7, 6, 0, 0, 4264, 4265, 7, 8, 0, 0, 4265, 4266, 7, 21, 0, 0, 4266, 306, + 1, 0, 0, 0, 4267, 4268, 7, 14, 0, 0, 4268, 4269, 7, 4, 0, 0, 4269, 4270, + 7, 0, 0, 0, 4270, 4271, 7, 20, 0, 0, 4271, 4272, 7, 9, 0, 0, 4272, 4273, + 7, 7, 0, 0, 4273, 4274, 7, 14, 0, 0, 4274, 4275, 7, 9, 0, 0, 4275, 308, + 1, 0, 0, 0, 4276, 4277, 7, 14, 0, 0, 4277, 4278, 7, 4, 0, 0, 4278, 4279, + 7, 20, 0, 0, 4279, 4280, 7, 20, 0, 0, 4280, 4281, 7, 0, 0, 0, 4281, 4282, + 7, 11, 0, 0, 4282, 4283, 7, 9, 0, 0, 4283, 310, 1, 0, 0, 0, 4284, 4285, + 7, 14, 0, 0, 4285, 4286, 7, 4, 0, 0, 4286, 4287, 7, 20, 0, 0, 4287, 4288, + 7, 20, 0, 0, 4288, 4289, 7, 9, 0, 0, 4289, 4290, 7, 14, 0, 0, 4290, 4291, + 7, 11, 0, 0, 4291, 4292, 7, 6, 0, 0, 4292, 4293, 7, 4, 0, 0, 4293, 4294, + 7, 8, 0, 0, 4294, 312, 1, 0, 0, 0, 4295, 4296, 7, 14, 0, 0, 4296, 4297, + 7, 4, 0, 0, 4297, 4298, 7, 20, 0, 0, 4298, 4299, 7, 17, 0, 0, 4299, 4300, + 7, 19, 0, 0, 4300, 4301, 7, 8, 0, 0, 4301, 314, 1, 0, 0, 0, 4302, 4303, + 7, 14, 0, 0, 4303, 4304, 7, 4, 0, 0, 4304, 4305, 7, 20, 0, 0, 4305, 4306, + 7, 17, 0, 0, 4306, 4307, 7, 19, 0, 0, 4307, 4308, 7, 8, 0, 0, 4308, 4309, + 7, 7, 0, 0, 4309, 316, 1, 0, 0, 0, 4310, 4311, 7, 14, 0, 0, 4311, 4312, + 7, 4, 0, 0, 4312, 4313, 7, 20, 0, 0, 4313, 4314, 5, 95, 0, 0, 4314, 4315, + 7, 20, 0, 0, 4315, 4316, 7, 9, 0, 0, 4316, 4317, 7, 8, 0, 0, 4317, 4318, + 7, 21, 0, 0, 4318, 4319, 7, 11, 0, 0, 4319, 4320, 7, 15, 0, 0, 4320, 318, + 1, 0, 0, 0, 4321, 4322, 7, 14, 0, 0, 4322, 4323, 7, 4, 0, 0, 4323, 4324, + 7, 20, 0, 0, 4324, 4325, 5, 95, 0, 0, 4325, 4326, 7, 8, 0, 0, 4326, 4327, + 7, 0, 0, 0, 4327, 4328, 7, 19, 0, 0, 4328, 4329, 7, 9, 0, 0, 4329, 320, + 1, 0, 0, 0, 4330, 4331, 7, 14, 0, 0, 4331, 4332, 7, 4, 0, 0, 4332, 4333, + 7, 19, 0, 0, 4333, 4334, 7, 19, 0, 0, 4334, 4335, 7, 9, 0, 0, 4335, 4336, + 7, 8, 0, 0, 4336, 4337, 7, 11, 0, 0, 4337, 322, 1, 0, 0, 0, 4338, 4339, + 7, 14, 0, 0, 4339, 4340, 7, 4, 0, 0, 4340, 4341, 7, 19, 0, 0, 4341, 4342, + 7, 19, 0, 0, 4342, 4343, 7, 6, 0, 0, 4343, 4344, 7, 11, 0, 0, 4344, 324, + 1, 0, 0, 0, 4345, 4346, 7, 14, 0, 0, 4346, 4347, 7, 4, 0, 0, 4347, 4348, + 7, 19, 0, 0, 4348, 4349, 7, 19, 0, 0, 4349, 4350, 7, 6, 0, 0, 4350, 4351, + 7, 11, 0, 0, 4351, 4352, 7, 11, 0, 0, 4352, 4353, 7, 9, 0, 0, 4353, 4354, + 7, 1, 0, 0, 4354, 326, 1, 0, 0, 0, 4355, 4356, 7, 14, 0, 0, 4356, 4357, + 7, 4, 0, 0, 4357, 4358, 7, 19, 0, 0, 4358, 4359, 7, 2, 0, 0, 4359, 4360, + 7, 3, 0, 0, 4360, 4361, 7, 9, 0, 0, 4361, 4362, 7, 7, 0, 0, 4362, 4363, + 7, 7, 0, 0, 4363, 328, 1, 0, 0, 0, 4364, 4365, 7, 14, 0, 0, 4365, 4366, + 7, 4, 0, 0, 4366, 4367, 7, 19, 0, 0, 4367, 4368, 7, 2, 0, 0, 4368, 4369, + 7, 3, 0, 0, 4369, 4370, 7, 9, 0, 0, 4370, 4371, 7, 7, 0, 0, 4371, 4372, + 7, 7, 0, 0, 4372, 4373, 7, 6, 0, 0, 4373, 4374, 7, 4, 0, 0, 4374, 4375, + 7, 8, 0, 0, 4375, 330, 1, 0, 0, 0, 4376, 4377, 7, 14, 0, 0, 4377, 4378, + 7, 4, 0, 0, 4378, 4379, 7, 8, 0, 0, 4379, 4380, 7, 14, 0, 0, 4380, 4381, + 7, 0, 0, 0, 4381, 4382, 7, 11, 0, 0, 4382, 332, 1, 0, 0, 0, 4383, 4384, + 7, 14, 0, 0, 4384, 4385, 7, 4, 0, 0, 4385, 4386, 7, 8, 0, 0, 4386, 4387, + 7, 14, 0, 0, 4387, 4388, 7, 0, 0, 0, 4388, 4389, 7, 11, 0, 0, 4389, 4390, + 5, 95, 0, 0, 4390, 4391, 7, 8, 0, 0, 4391, 4392, 7, 17, 0, 0, 4392, 4393, + 7, 20, 0, 0, 4393, 4394, 7, 20, 0, 0, 4394, 4395, 5, 95, 0, 0, 4395, 4396, + 7, 18, 0, 0, 4396, 4397, 7, 6, 0, 0, 4397, 4398, 7, 9, 0, 0, 4398, 4399, + 7, 20, 0, 0, 4399, 4400, 7, 1, 0, 0, 4400, 4401, 7, 7, 0, 0, 4401, 4402, + 5, 95, 0, 0, 4402, 4403, 7, 8, 0, 0, 4403, 4404, 7, 17, 0, 0, 4404, 4405, + 7, 20, 0, 0, 4405, 4406, 7, 20, 0, 0, 4406, 334, 1, 0, 0, 0, 4407, 4408, + 7, 14, 0, 0, 4408, 4409, 7, 4, 0, 0, 4409, 4410, 7, 8, 0, 0, 4410, 4411, + 7, 14, 0, 0, 4411, 4412, 7, 0, 0, 0, 4412, 4413, 7, 11, 0, 0, 4413, 4414, + 5, 95, 0, 0, 4414, 4415, 7, 13, 0, 0, 4415, 4416, 7, 7, 0, 0, 4416, 336, + 1, 0, 0, 0, 4417, 4418, 7, 14, 0, 0, 4418, 4419, 7, 4, 0, 0, 4419, 4420, + 7, 8, 0, 0, 4420, 4421, 7, 1, 0, 0, 4421, 4422, 7, 6, 0, 0, 4422, 4423, + 7, 11, 0, 0, 4423, 4424, 7, 6, 0, 0, 4424, 4425, 7, 4, 0, 0, 4425, 4426, + 7, 8, 0, 0, 4426, 338, 1, 0, 0, 0, 4427, 4428, 7, 14, 0, 0, 4428, 4429, + 7, 4, 0, 0, 4429, 4430, 7, 8, 0, 0, 4430, 4431, 7, 12, 0, 0, 4431, 4432, + 7, 6, 0, 0, 4432, 4433, 7, 21, 0, 0, 4433, 4434, 7, 17, 0, 0, 4434, 4435, + 7, 3, 0, 0, 4435, 4436, 7, 0, 0, 0, 4436, 4437, 7, 11, 0, 0, 4437, 4438, + 7, 6, 0, 0, 4438, 4439, 7, 4, 0, 0, 4439, 4440, 7, 8, 0, 0, 4440, 340, + 1, 0, 0, 0, 4441, 4442, 7, 14, 0, 0, 4442, 4443, 7, 4, 0, 0, 4443, 4444, + 7, 8, 0, 0, 4444, 4445, 7, 8, 0, 0, 4445, 4446, 7, 9, 0, 0, 4446, 4447, + 7, 14, 0, 0, 4447, 4448, 7, 11, 0, 0, 4448, 342, 1, 0, 0, 0, 4449, 4450, + 7, 14, 0, 0, 4450, 4451, 7, 4, 0, 0, 4451, 4452, 7, 8, 0, 0, 4452, 4453, + 7, 8, 0, 0, 4453, 4454, 7, 9, 0, 0, 4454, 4455, 7, 14, 0, 0, 4455, 4456, + 7, 11, 0, 0, 4456, 4457, 7, 6, 0, 0, 4457, 4458, 7, 4, 0, 0, 4458, 4459, + 7, 8, 0, 0, 4459, 344, 1, 0, 0, 0, 4460, 4461, 7, 14, 0, 0, 4461, 4462, + 7, 4, 0, 0, 4462, 4463, 7, 8, 0, 0, 4463, 4464, 7, 8, 0, 0, 4464, 4465, + 7, 9, 0, 0, 4465, 4466, 7, 14, 0, 0, 4466, 4467, 7, 11, 0, 0, 4467, 4468, + 7, 6, 0, 0, 4468, 4469, 7, 4, 0, 0, 4469, 4470, 7, 8, 0, 0, 4470, 4471, + 7, 7, 0, 0, 4471, 346, 1, 0, 0, 0, 4472, 4473, 7, 14, 0, 0, 4473, 4474, + 7, 4, 0, 0, 4474, 4475, 7, 8, 0, 0, 4475, 4476, 7, 7, 0, 0, 4476, 4477, + 7, 11, 0, 0, 4477, 4478, 7, 3, 0, 0, 4478, 4479, 7, 0, 0, 0, 4479, 4480, + 7, 6, 0, 0, 4480, 4481, 7, 8, 0, 0, 4481, 4482, 7, 11, 0, 0, 4482, 348, + 1, 0, 0, 0, 4483, 4484, 7, 14, 0, 0, 4484, 4485, 7, 4, 0, 0, 4485, 4486, + 7, 8, 0, 0, 4486, 4487, 7, 11, 0, 0, 4487, 4488, 7, 0, 0, 0, 4488, 4489, + 7, 6, 0, 0, 4489, 4490, 7, 8, 0, 0, 4490, 4491, 7, 19, 0, 0, 4491, 4492, + 7, 9, 0, 0, 4492, 4493, 7, 8, 0, 0, 4493, 4494, 7, 11, 0, 0, 4494, 350, + 1, 0, 0, 0, 4495, 4496, 7, 14, 0, 0, 4496, 4497, 7, 4, 0, 0, 4497, 4498, + 7, 8, 0, 0, 4498, 4499, 7, 11, 0, 0, 4499, 4500, 7, 0, 0, 0, 4500, 4501, + 7, 6, 0, 0, 4501, 4502, 7, 8, 0, 0, 4502, 4503, 7, 7, 0, 0, 4503, 352, + 1, 0, 0, 0, 4504, 4505, 7, 14, 0, 0, 4505, 4506, 7, 4, 0, 0, 4506, 4507, + 7, 8, 0, 0, 4507, 4508, 7, 11, 0, 0, 4508, 4509, 7, 9, 0, 0, 4509, 4510, + 7, 8, 0, 0, 4510, 4511, 7, 11, 0, 0, 4511, 354, 1, 0, 0, 0, 4512, 4513, + 7, 14, 0, 0, 4513, 4514, 7, 4, 0, 0, 4514, 4515, 7, 8, 0, 0, 4515, 4516, + 7, 11, 0, 0, 4516, 4517, 7, 9, 0, 0, 4517, 4518, 7, 23, 0, 0, 4518, 4519, + 7, 11, 0, 0, 4519, 356, 1, 0, 0, 0, 4520, 4521, 7, 14, 0, 0, 4521, 4522, + 7, 4, 0, 0, 4522, 4523, 7, 8, 0, 0, 4523, 4524, 7, 11, 0, 0, 4524, 4525, + 7, 9, 0, 0, 4525, 4526, 7, 23, 0, 0, 4526, 4527, 7, 11, 0, 0, 4527, 4528, + 5, 95, 0, 0, 4528, 4529, 7, 15, 0, 0, 4529, 4530, 7, 9, 0, 0, 4530, 4531, + 7, 0, 0, 0, 4531, 4532, 7, 1, 0, 0, 4532, 4533, 7, 9, 0, 0, 4533, 4534, + 7, 3, 0, 0, 4534, 4535, 7, 7, 0, 0, 4535, 358, 1, 0, 0, 0, 4536, 4537, + 7, 14, 0, 0, 4537, 4538, 7, 4, 0, 0, 4538, 4539, 7, 8, 0, 0, 4539, 4540, + 7, 11, 0, 0, 4540, 4541, 7, 9, 0, 0, 4541, 4542, 7, 23, 0, 0, 4542, 4543, + 7, 11, 0, 0, 4543, 4544, 5, 95, 0, 0, 4544, 4545, 7, 6, 0, 0, 4545, 4546, + 7, 8, 0, 0, 4546, 4547, 7, 12, 0, 0, 4547, 4548, 7, 4, 0, 0, 4548, 360, + 1, 0, 0, 0, 4549, 4550, 7, 14, 0, 0, 4550, 4551, 7, 4, 0, 0, 4551, 4552, + 7, 8, 0, 0, 4552, 4553, 7, 11, 0, 0, 4553, 4554, 7, 6, 0, 0, 4554, 4555, + 7, 8, 0, 0, 4555, 4556, 7, 17, 0, 0, 4556, 4557, 7, 9, 0, 0, 4557, 362, + 1, 0, 0, 0, 4558, 4559, 7, 14, 0, 0, 4559, 4560, 7, 4, 0, 0, 4560, 4561, + 7, 8, 0, 0, 4561, 4562, 7, 11, 0, 0, 4562, 4563, 7, 3, 0, 0, 4563, 4564, + 7, 4, 0, 0, 4564, 4565, 7, 20, 0, 0, 4565, 364, 1, 0, 0, 0, 4566, 4567, + 7, 14, 0, 0, 4567, 4568, 7, 4, 0, 0, 4568, 4569, 7, 8, 0, 0, 4569, 4570, + 7, 5, 0, 0, 4570, 4571, 7, 9, 0, 0, 4571, 4572, 7, 3, 0, 0, 4572, 4573, + 7, 7, 0, 0, 4573, 4574, 7, 0, 0, 0, 4574, 4575, 7, 11, 0, 0, 4575, 4576, + 7, 6, 0, 0, 4576, 4577, 7, 4, 0, 0, 4577, 4578, 7, 8, 0, 0, 4578, 366, + 1, 0, 0, 0, 4579, 4580, 7, 14, 0, 0, 4580, 4581, 7, 4, 0, 0, 4581, 4582, + 7, 4, 0, 0, 4582, 4583, 7, 22, 0, 0, 4583, 4584, 7, 6, 0, 0, 4584, 4585, + 7, 9, 0, 0, 4585, 368, 1, 0, 0, 0, 4586, 4587, 7, 14, 0, 0, 4587, 4588, + 7, 4, 0, 0, 4588, 4589, 7, 2, 0, 0, 4589, 4590, 7, 18, 0, 0, 4590, 370, + 1, 0, 0, 0, 4591, 4592, 7, 14, 0, 0, 4592, 4593, 7, 4, 0, 0, 4593, 4594, + 7, 2, 0, 0, 4594, 4595, 7, 18, 0, 0, 4595, 4596, 5, 95, 0, 0, 4596, 4597, + 7, 4, 0, 0, 4597, 4598, 7, 8, 0, 0, 4598, 4599, 7, 20, 0, 0, 4599, 4600, + 7, 18, 0, 0, 4600, 372, 1, 0, 0, 0, 4601, 4602, 7, 14, 0, 0, 4602, 4603, + 7, 4, 0, 0, 4603, 4604, 7, 2, 0, 0, 4604, 4605, 7, 18, 0, 0, 4605, 4606, + 5, 95, 0, 0, 4606, 4607, 7, 4, 0, 0, 4607, 4608, 7, 2, 0, 0, 4608, 4609, + 7, 11, 0, 0, 4609, 4610, 7, 6, 0, 0, 4610, 4611, 7, 4, 0, 0, 4611, 4612, + 7, 8, 0, 0, 4612, 4613, 7, 7, 0, 0, 4613, 374, 1, 0, 0, 0, 4614, 4615, + 7, 14, 0, 0, 4615, 4616, 7, 4, 0, 0, 4616, 4617, 7, 17, 0, 0, 4617, 4618, + 7, 8, 0, 0, 4618, 4619, 7, 11, 0, 0, 4619, 376, 1, 0, 0, 0, 4620, 4621, + 7, 14, 0, 0, 4621, 4622, 7, 4, 0, 0, 4622, 4623, 7, 17, 0, 0, 4623, 4624, + 7, 8, 0, 0, 4624, 4625, 7, 11, 0, 0, 4625, 4626, 5, 95, 0, 0, 4626, 4627, + 7, 10, 0, 0, 4627, 4628, 7, 6, 0, 0, 4628, 4629, 7, 21, 0, 0, 4629, 378, + 1, 0, 0, 0, 4630, 4631, 7, 14, 0, 0, 4631, 4632, 7, 3, 0, 0, 4632, 4633, + 7, 9, 0, 0, 4633, 4634, 7, 0, 0, 0, 4634, 4635, 7, 11, 0, 0, 4635, 4636, + 7, 9, 0, 0, 4636, 380, 1, 0, 0, 0, 4637, 4638, 7, 14, 0, 0, 4638, 4639, + 7, 3, 0, 0, 4639, 4640, 7, 9, 0, 0, 4640, 4641, 7, 1, 0, 0, 4641, 4642, + 7, 9, 0, 0, 4642, 4643, 7, 8, 0, 0, 4643, 4644, 7, 11, 0, 0, 4644, 4645, + 7, 6, 0, 0, 4645, 4646, 7, 0, 0, 0, 4646, 4647, 7, 20, 0, 0, 4647, 4648, + 7, 7, 0, 0, 4648, 382, 1, 0, 0, 0, 4649, 4650, 7, 14, 0, 0, 4650, 4651, + 7, 3, 0, 0, 4651, 4652, 7, 9, 0, 0, 4652, 4653, 7, 1, 0, 0, 4653, 4654, + 7, 6, 0, 0, 4654, 4655, 7, 11, 0, 0, 4655, 4656, 5, 95, 0, 0, 4656, 4657, + 7, 16, 0, 0, 4657, 4658, 7, 17, 0, 0, 4658, 4659, 7, 4, 0, 0, 4659, 4660, + 7, 11, 0, 0, 4660, 4661, 7, 0, 0, 0, 4661, 384, 1, 0, 0, 0, 4662, 4663, + 7, 14, 0, 0, 4663, 4664, 7, 3, 0, 0, 4664, 4665, 7, 4, 0, 0, 4665, 4666, + 7, 7, 0, 0, 4666, 4667, 7, 7, 0, 0, 4667, 386, 1, 0, 0, 0, 4668, 4669, + 7, 14, 0, 0, 4669, 4670, 7, 7, 0, 0, 4670, 4671, 7, 5, 0, 0, 4671, 388, + 1, 0, 0, 0, 4672, 4673, 5, 39, 0, 0, 4673, 4674, 7, 14, 0, 0, 4674, 4675, + 7, 7, 0, 0, 4675, 4676, 7, 5, 0, 0, 4676, 4677, 5, 39, 0, 0, 4677, 390, + 1, 0, 0, 0, 4678, 4679, 7, 14, 0, 0, 4679, 4680, 7, 17, 0, 0, 4680, 4681, + 7, 10, 0, 0, 4681, 4682, 7, 9, 0, 0, 4682, 392, 1, 0, 0, 0, 4683, 4684, + 7, 14, 0, 0, 4684, 4685, 7, 17, 0, 0, 4685, 4686, 7, 19, 0, 0, 4686, 4687, + 7, 9, 0, 0, 4687, 4688, 5, 95, 0, 0, 4688, 4689, 7, 1, 0, 0, 4689, 4690, + 7, 6, 0, 0, 4690, 4691, 7, 7, 0, 0, 4691, 4692, 7, 11, 0, 0, 4692, 394, + 1, 0, 0, 0, 4693, 4694, 7, 14, 0, 0, 4694, 4695, 7, 17, 0, 0, 4695, 4696, + 7, 3, 0, 0, 4696, 4697, 7, 3, 0, 0, 4697, 4698, 7, 9, 0, 0, 4698, 4699, + 7, 8, 0, 0, 4699, 4700, 7, 11, 0, 0, 4700, 396, 1, 0, 0, 0, 4701, 4702, + 7, 14, 0, 0, 4702, 4703, 7, 17, 0, 0, 4703, 4704, 7, 3, 0, 0, 4704, 4705, + 7, 3, 0, 0, 4705, 4706, 7, 9, 0, 0, 4706, 4707, 7, 8, 0, 0, 4707, 4708, + 7, 11, 0, 0, 4708, 4709, 5, 95, 0, 0, 4709, 4710, 7, 1, 0, 0, 4710, 4711, + 7, 0, 0, 0, 4711, 4712, 7, 11, 0, 0, 4712, 4713, 7, 9, 0, 0, 4713, 398, + 1, 0, 0, 0, 4714, 4715, 7, 14, 0, 0, 4715, 4716, 7, 17, 0, 0, 4716, 4717, + 7, 3, 0, 0, 4717, 4718, 7, 3, 0, 0, 4718, 4719, 7, 9, 0, 0, 4719, 4720, + 7, 8, 0, 0, 4720, 4721, 7, 11, 0, 0, 4721, 4722, 5, 95, 0, 0, 4722, 4723, + 7, 11, 0, 0, 4723, 4724, 7, 6, 0, 0, 4724, 4725, 7, 19, 0, 0, 4725, 4726, + 7, 9, 0, 0, 4726, 400, 1, 0, 0, 0, 4727, 4728, 7, 14, 0, 0, 4728, 4729, + 7, 17, 0, 0, 4729, 4730, 7, 3, 0, 0, 4730, 4731, 7, 3, 0, 0, 4731, 4732, + 7, 9, 0, 0, 4732, 4733, 7, 8, 0, 0, 4733, 4734, 7, 11, 0, 0, 4734, 4735, + 5, 95, 0, 0, 4735, 4736, 7, 11, 0, 0, 4736, 4737, 7, 6, 0, 0, 4737, 4738, + 7, 19, 0, 0, 4738, 4739, 7, 9, 0, 0, 4739, 4740, 7, 7, 0, 0, 4740, 4741, + 7, 11, 0, 0, 4741, 4742, 7, 0, 0, 0, 4742, 4743, 7, 19, 0, 0, 4743, 4744, + 7, 2, 0, 0, 4744, 402, 1, 0, 0, 0, 4745, 4746, 7, 14, 0, 0, 4746, 4747, + 7, 17, 0, 0, 4747, 4748, 7, 3, 0, 0, 4748, 4749, 7, 3, 0, 0, 4749, 4750, + 7, 9, 0, 0, 4750, 4751, 7, 8, 0, 0, 4751, 4752, 7, 11, 0, 0, 4752, 4753, + 5, 95, 0, 0, 4753, 4754, 7, 17, 0, 0, 4754, 4755, 7, 7, 0, 0, 4755, 4756, + 7, 9, 0, 0, 4756, 4757, 7, 3, 0, 0, 4757, 404, 1, 0, 0, 0, 4758, 4759, + 7, 14, 0, 0, 4759, 4760, 7, 17, 0, 0, 4760, 4761, 7, 3, 0, 0, 4761, 4762, + 7, 7, 0, 0, 4762, 4763, 7, 4, 0, 0, 4763, 4764, 7, 3, 0, 0, 4764, 406, + 1, 0, 0, 0, 4765, 4766, 7, 14, 0, 0, 4766, 4767, 7, 17, 0, 0, 4767, 4768, + 7, 7, 0, 0, 4768, 4769, 7, 11, 0, 0, 4769, 4770, 7, 4, 0, 0, 4770, 4771, + 7, 19, 0, 0, 4771, 408, 1, 0, 0, 0, 4772, 4773, 7, 1, 0, 0, 4773, 4774, + 7, 0, 0, 0, 4774, 4775, 7, 6, 0, 0, 4775, 4776, 7, 20, 0, 0, 4776, 4777, + 7, 18, 0, 0, 4777, 410, 1, 0, 0, 0, 4778, 4779, 7, 1, 0, 0, 4779, 4780, + 7, 0, 0, 0, 4780, 4781, 7, 11, 0, 0, 4781, 4782, 7, 0, 0, 0, 4782, 412, + 1, 0, 0, 0, 4783, 4784, 7, 1, 0, 0, 4784, 4785, 7, 0, 0, 0, 4785, 4786, + 7, 11, 0, 0, 4786, 4787, 7, 0, 0, 0, 4787, 4788, 7, 10, 0, 0, 4788, 4789, + 7, 0, 0, 0, 4789, 4790, 7, 7, 0, 0, 4790, 4791, 7, 9, 0, 0, 4791, 414, + 1, 0, 0, 0, 4792, 4793, 7, 1, 0, 0, 4793, 4794, 7, 0, 0, 0, 4794, 4795, + 7, 11, 0, 0, 4795, 4796, 7, 0, 0, 0, 4796, 4797, 7, 10, 0, 0, 4797, 4798, + 7, 0, 0, 0, 4798, 4799, 7, 7, 0, 0, 4799, 4800, 7, 9, 0, 0, 4800, 4801, + 7, 7, 0, 0, 4801, 416, 1, 0, 0, 0, 4802, 4803, 7, 1, 0, 0, 4803, 4804, + 7, 0, 0, 0, 4804, 4805, 7, 11, 0, 0, 4805, 4806, 7, 0, 0, 0, 4806, 4807, + 5, 95, 0, 0, 4807, 4808, 7, 3, 0, 0, 4808, 4809, 7, 9, 0, 0, 4809, 4810, + 7, 11, 0, 0, 4810, 4811, 7, 9, 0, 0, 4811, 4812, 7, 8, 0, 0, 4812, 4813, + 7, 11, 0, 0, 4813, 4814, 7, 6, 0, 0, 4814, 4815, 7, 4, 0, 0, 4815, 4816, + 7, 8, 0, 0, 4816, 4817, 5, 95, 0, 0, 4817, 4818, 7, 11, 0, 0, 4818, 4819, + 7, 6, 0, 0, 4819, 4820, 7, 19, 0, 0, 4820, 4821, 7, 9, 0, 0, 4821, 4822, + 5, 95, 0, 0, 4822, 4823, 7, 6, 0, 0, 4823, 4824, 7, 8, 0, 0, 4824, 4825, + 5, 95, 0, 0, 4825, 4826, 7, 1, 0, 0, 4826, 4827, 7, 0, 0, 0, 4827, 4828, + 7, 18, 0, 0, 4828, 4829, 7, 7, 0, 0, 4829, 418, 1, 0, 0, 0, 4830, 4831, + 7, 1, 0, 0, 4831, 4832, 7, 0, 0, 0, 4832, 4833, 7, 11, 0, 0, 4833, 4834, + 7, 9, 0, 0, 4834, 4835, 7, 0, 0, 0, 4835, 4836, 7, 1, 0, 0, 4836, 4837, + 7, 1, 0, 0, 4837, 420, 1, 0, 0, 0, 4838, 4839, 7, 1, 0, 0, 4839, 4840, + 7, 0, 0, 0, 4840, 4841, 7, 11, 0, 0, 4841, 4842, 7, 9, 0, 0, 4842, 4843, + 7, 1, 0, 0, 4843, 4844, 7, 6, 0, 0, 4844, 4845, 7, 12, 0, 0, 4845, 4846, + 7, 12, 0, 0, 4846, 422, 1, 0, 0, 0, 4847, 4848, 7, 1, 0, 0, 4848, 4849, + 7, 0, 0, 0, 4849, 4850, 7, 11, 0, 0, 4850, 4851, 7, 9, 0, 0, 4851, 4852, + 7, 8, 0, 0, 4852, 4853, 7, 0, 0, 0, 4853, 4854, 7, 19, 0, 0, 4854, 4855, + 7, 9, 0, 0, 4855, 424, 1, 0, 0, 0, 4856, 4857, 7, 1, 0, 0, 4857, 4858, + 7, 0, 0, 0, 4858, 4859, 7, 11, 0, 0, 4859, 4860, 7, 9, 0, 0, 4860, 4861, + 7, 2, 0, 0, 4861, 4862, 7, 0, 0, 0, 4862, 4863, 7, 3, 0, 0, 4863, 4864, + 7, 11, 0, 0, 4864, 426, 1, 0, 0, 0, 4865, 4866, 7, 1, 0, 0, 4866, 4867, + 7, 0, 0, 0, 4867, 4868, 7, 11, 0, 0, 4868, 4869, 7, 9, 0, 0, 4869, 4870, + 5, 95, 0, 0, 4870, 4871, 7, 12, 0, 0, 4871, 4872, 7, 4, 0, 0, 4872, 4873, + 7, 3, 0, 0, 4873, 4874, 7, 19, 0, 0, 4874, 4875, 7, 0, 0, 0, 4875, 4876, + 7, 11, 0, 0, 4876, 428, 1, 0, 0, 0, 4877, 4878, 7, 1, 0, 0, 4878, 4879, + 7, 0, 0, 0, 4879, 4880, 7, 11, 0, 0, 4880, 4881, 7, 9, 0, 0, 4881, 4882, + 5, 95, 0, 0, 4882, 4883, 7, 6, 0, 0, 4883, 4884, 7, 8, 0, 0, 4884, 4885, + 7, 2, 0, 0, 4885, 4886, 7, 17, 0, 0, 4886, 4887, 7, 11, 0, 0, 4887, 4888, + 5, 95, 0, 0, 4888, 4889, 7, 12, 0, 0, 4889, 4890, 7, 4, 0, 0, 4890, 4891, + 7, 3, 0, 0, 4891, 4892, 7, 19, 0, 0, 4892, 4893, 7, 0, 0, 0, 4893, 4894, + 7, 11, 0, 0, 4894, 430, 1, 0, 0, 0, 4895, 4896, 7, 1, 0, 0, 4896, 4897, + 7, 0, 0, 0, 4897, 4898, 7, 11, 0, 0, 4898, 4899, 7, 9, 0, 0, 4899, 4900, + 5, 95, 0, 0, 4900, 4901, 7, 4, 0, 0, 4901, 4902, 7, 17, 0, 0, 4902, 4903, + 7, 11, 0, 0, 4903, 4904, 7, 2, 0, 0, 4904, 4905, 7, 17, 0, 0, 4905, 4906, + 7, 11, 0, 0, 4906, 4907, 5, 95, 0, 0, 4907, 4908, 7, 12, 0, 0, 4908, 4909, + 7, 4, 0, 0, 4909, 4910, 7, 3, 0, 0, 4910, 4911, 7, 19, 0, 0, 4911, 4912, + 7, 0, 0, 0, 4912, 4913, 7, 11, 0, 0, 4913, 432, 1, 0, 0, 0, 4914, 4915, + 7, 1, 0, 0, 4915, 4916, 7, 0, 0, 0, 4916, 4917, 7, 11, 0, 0, 4917, 4918, + 7, 9, 0, 0, 4918, 4919, 5, 95, 0, 0, 4919, 4920, 7, 2, 0, 0, 4920, 4921, + 7, 0, 0, 0, 4921, 4922, 7, 3, 0, 0, 4922, 4923, 7, 11, 0, 0, 4923, 434, + 1, 0, 0, 0, 4924, 4925, 7, 1, 0, 0, 4925, 4926, 7, 0, 0, 0, 4926, 4927, + 7, 18, 0, 0, 4927, 4928, 7, 7, 0, 0, 4928, 436, 1, 0, 0, 0, 4929, 4930, + 7, 1, 0, 0, 4930, 4931, 7, 0, 0, 0, 4931, 4932, 7, 18, 0, 0, 4932, 4933, + 7, 7, 0, 0, 4933, 4934, 5, 95, 0, 0, 4934, 4935, 7, 11, 0, 0, 4935, 4936, + 7, 4, 0, 0, 4936, 4937, 5, 95, 0, 0, 4937, 4938, 7, 9, 0, 0, 4938, 4939, + 7, 23, 0, 0, 4939, 4940, 7, 2, 0, 0, 4940, 4941, 7, 6, 0, 0, 4941, 4942, + 7, 3, 0, 0, 4942, 4943, 7, 18, 0, 0, 4943, 438, 1, 0, 0, 0, 4944, 4945, + 7, 1, 0, 0, 4945, 4946, 7, 9, 0, 0, 4946, 4947, 7, 14, 0, 0, 4947, 4948, + 7, 20, 0, 0, 4948, 4949, 7, 0, 0, 0, 4949, 4950, 7, 3, 0, 0, 4950, 4951, + 7, 9, 0, 0, 4951, 440, 1, 0, 0, 0, 4952, 4953, 7, 1, 0, 0, 4953, 4954, + 7, 9, 0, 0, 4954, 4955, 7, 12, 0, 0, 4955, 4956, 7, 0, 0, 0, 4956, 4957, + 7, 17, 0, 0, 4957, 4958, 7, 20, 0, 0, 4958, 4959, 7, 11, 0, 0, 4959, 442, + 1, 0, 0, 0, 4960, 4961, 7, 1, 0, 0, 4961, 4962, 7, 9, 0, 0, 4962, 4963, + 7, 12, 0, 0, 4963, 4964, 7, 0, 0, 0, 4964, 4965, 7, 17, 0, 0, 4965, 4966, + 7, 20, 0, 0, 4966, 4967, 7, 11, 0, 0, 4967, 4968, 5, 95, 0, 0, 4968, 4969, + 7, 1, 0, 0, 4969, 4970, 7, 1, 0, 0, 4970, 4971, 7, 20, 0, 0, 4971, 4972, + 5, 95, 0, 0, 4972, 4973, 7, 14, 0, 0, 4973, 4974, 7, 4, 0, 0, 4974, 4975, + 7, 20, 0, 0, 4975, 4976, 7, 20, 0, 0, 4976, 4977, 7, 0, 0, 0, 4977, 4978, + 7, 11, 0, 0, 4978, 4979, 7, 6, 0, 0, 4979, 4980, 7, 4, 0, 0, 4980, 4981, + 7, 8, 0, 0, 4981, 444, 1, 0, 0, 0, 4982, 4983, 7, 1, 0, 0, 4983, 4984, + 7, 9, 0, 0, 4984, 4985, 7, 12, 0, 0, 4985, 4986, 7, 0, 0, 0, 4986, 4987, + 7, 17, 0, 0, 4987, 4988, 7, 20, 0, 0, 4988, 4989, 7, 11, 0, 0, 4989, 4990, + 5, 95, 0, 0, 4990, 4991, 7, 8, 0, 0, 4991, 4992, 7, 0, 0, 0, 4992, 4993, + 7, 19, 0, 0, 4993, 4994, 7, 9, 0, 0, 4994, 4995, 7, 7, 0, 0, 4995, 4996, + 7, 2, 0, 0, 4996, 4997, 7, 0, 0, 0, 4997, 4998, 7, 14, 0, 0, 4998, 4999, + 7, 9, 0, 0, 4999, 446, 1, 0, 0, 0, 5000, 5001, 7, 1, 0, 0, 5001, 5002, + 7, 9, 0, 0, 5002, 5003, 7, 12, 0, 0, 5003, 5004, 7, 0, 0, 0, 5004, 5005, + 7, 17, 0, 0, 5005, 5006, 7, 20, 0, 0, 5006, 5007, 7, 11, 0, 0, 5007, 5008, + 5, 95, 0, 0, 5008, 5009, 7, 3, 0, 0, 5009, 5010, 7, 4, 0, 0, 5010, 5011, + 7, 20, 0, 0, 5011, 5012, 7, 9, 0, 0, 5012, 448, 1, 0, 0, 0, 5013, 5014, + 7, 1, 0, 0, 5014, 5015, 7, 9, 0, 0, 5015, 5016, 7, 12, 0, 0, 5016, 5017, + 7, 0, 0, 0, 5017, 5018, 7, 17, 0, 0, 5018, 5019, 7, 20, 0, 0, 5019, 5020, + 7, 11, 0, 0, 5020, 5021, 5, 95, 0, 0, 5021, 5022, 7, 13, 0, 0, 5022, 5023, + 7, 0, 0, 0, 5023, 5024, 7, 3, 0, 0, 5024, 5025, 7, 9, 0, 0, 5025, 5026, + 7, 15, 0, 0, 5026, 5027, 7, 4, 0, 0, 5027, 5028, 7, 17, 0, 0, 5028, 5029, + 7, 7, 0, 0, 5029, 5030, 7, 9, 0, 0, 5030, 450, 1, 0, 0, 0, 5031, 5032, + 7, 1, 0, 0, 5032, 5033, 7, 9, 0, 0, 5033, 5034, 7, 12, 0, 0, 5034, 5035, + 7, 9, 0, 0, 5035, 5036, 7, 3, 0, 0, 5036, 5037, 7, 3, 0, 0, 5037, 5038, + 7, 0, 0, 0, 5038, 5039, 7, 10, 0, 0, 5039, 5040, 7, 20, 0, 0, 5040, 5041, + 7, 9, 0, 0, 5041, 452, 1, 0, 0, 0, 5042, 5043, 7, 1, 0, 0, 5043, 5044, + 7, 9, 0, 0, 5044, 5045, 7, 12, 0, 0, 5045, 5046, 7, 9, 0, 0, 5046, 5047, + 7, 3, 0, 0, 5047, 5048, 7, 3, 0, 0, 5048, 5049, 7, 9, 0, 0, 5049, 5050, + 7, 1, 0, 0, 5050, 454, 1, 0, 0, 0, 5051, 5052, 7, 1, 0, 0, 5052, 5053, + 7, 9, 0, 0, 5053, 5054, 7, 12, 0, 0, 5054, 5055, 7, 6, 0, 0, 5055, 5056, + 7, 8, 0, 0, 5056, 5057, 7, 9, 0, 0, 5057, 456, 1, 0, 0, 0, 5058, 5059, + 7, 1, 0, 0, 5059, 5060, 7, 9, 0, 0, 5060, 5061, 7, 12, 0, 0, 5061, 5062, + 7, 6, 0, 0, 5062, 5063, 7, 8, 0, 0, 5063, 5064, 7, 6, 0, 0, 5064, 5065, + 7, 11, 0, 0, 5065, 5066, 7, 6, 0, 0, 5066, 5067, 7, 4, 0, 0, 5067, 5068, + 7, 8, 0, 0, 5068, 458, 1, 0, 0, 0, 5069, 5070, 7, 1, 0, 0, 5070, 5071, + 7, 9, 0, 0, 5071, 5072, 7, 12, 0, 0, 5072, 5073, 7, 20, 0, 0, 5073, 5074, + 7, 0, 0, 0, 5074, 5075, 7, 11, 0, 0, 5075, 5076, 7, 9, 0, 0, 5076, 460, + 1, 0, 0, 0, 5077, 5078, 7, 1, 0, 0, 5078, 5079, 7, 9, 0, 0, 5079, 5080, + 7, 20, 0, 0, 5080, 5081, 7, 9, 0, 0, 5081, 5082, 7, 21, 0, 0, 5082, 5083, + 7, 0, 0, 0, 5083, 5084, 7, 11, 0, 0, 5084, 5085, 7, 9, 0, 0, 5085, 5086, + 7, 1, 0, 0, 5086, 462, 1, 0, 0, 0, 5087, 5088, 7, 1, 0, 0, 5088, 5089, + 7, 9, 0, 0, 5089, 5090, 7, 20, 0, 0, 5090, 5091, 7, 9, 0, 0, 5091, 5092, + 7, 11, 0, 0, 5092, 5093, 7, 9, 0, 0, 5093, 464, 1, 0, 0, 0, 5094, 5095, + 7, 1, 0, 0, 5095, 5096, 7, 9, 0, 0, 5096, 5097, 7, 20, 0, 0, 5097, 5098, + 7, 11, 0, 0, 5098, 5099, 7, 0, 0, 0, 5099, 466, 1, 0, 0, 0, 5100, 5101, + 7, 1, 0, 0, 5101, 5102, 7, 9, 0, 0, 5102, 5103, 7, 8, 0, 0, 5103, 5104, + 7, 7, 0, 0, 5104, 5105, 7, 9, 0, 0, 5105, 5106, 5, 95, 0, 0, 5106, 5107, + 7, 3, 0, 0, 5107, 5108, 7, 0, 0, 0, 5108, 5109, 7, 8, 0, 0, 5109, 5110, + 7, 22, 0, 0, 5110, 468, 1, 0, 0, 0, 5111, 5112, 7, 1, 0, 0, 5112, 5113, + 7, 9, 0, 0, 5113, 5114, 7, 7, 0, 0, 5114, 5115, 7, 14, 0, 0, 5115, 470, + 1, 0, 0, 0, 5116, 5117, 7, 1, 0, 0, 5117, 5118, 7, 9, 0, 0, 5118, 5119, + 7, 7, 0, 0, 5119, 5120, 7, 14, 0, 0, 5120, 5121, 7, 3, 0, 0, 5121, 5122, + 7, 6, 0, 0, 5122, 5123, 7, 10, 0, 0, 5123, 5124, 7, 9, 0, 0, 5124, 472, + 1, 0, 0, 0, 5125, 5126, 7, 1, 0, 0, 5126, 5127, 7, 6, 0, 0, 5127, 5128, + 7, 3, 0, 0, 5128, 5129, 7, 9, 0, 0, 5129, 5130, 7, 14, 0, 0, 5130, 5131, + 7, 11, 0, 0, 5131, 5132, 7, 6, 0, 0, 5132, 5133, 7, 4, 0, 0, 5133, 5134, + 7, 8, 0, 0, 5134, 474, 1, 0, 0, 0, 5135, 5136, 7, 1, 0, 0, 5136, 5137, + 7, 6, 0, 0, 5137, 5138, 7, 3, 0, 0, 5138, 5139, 7, 9, 0, 0, 5139, 5140, + 7, 14, 0, 0, 5140, 5141, 7, 11, 0, 0, 5141, 5142, 7, 4, 0, 0, 5142, 5143, + 7, 3, 0, 0, 5143, 5144, 7, 18, 0, 0, 5144, 476, 1, 0, 0, 0, 5145, 5146, + 7, 1, 0, 0, 5146, 5147, 7, 6, 0, 0, 5147, 5148, 7, 7, 0, 0, 5148, 5149, + 7, 0, 0, 0, 5149, 5150, 7, 10, 0, 0, 5150, 5151, 7, 20, 0, 0, 5151, 5152, + 7, 9, 0, 0, 5152, 478, 1, 0, 0, 0, 5153, 5154, 7, 1, 0, 0, 5154, 5155, + 7, 6, 0, 0, 5155, 5156, 7, 7, 0, 0, 5156, 5157, 7, 0, 0, 0, 5157, 5158, + 7, 10, 0, 0, 5158, 5159, 7, 20, 0, 0, 5159, 5160, 7, 9, 0, 0, 5160, 5161, + 7, 1, 0, 0, 5161, 480, 1, 0, 0, 0, 5162, 5163, 7, 1, 0, 0, 5163, 5164, + 7, 6, 0, 0, 5164, 5165, 7, 7, 0, 0, 5165, 5166, 7, 0, 0, 0, 5166, 5167, + 7, 10, 0, 0, 5167, 5168, 7, 20, 0, 0, 5168, 5169, 7, 9, 0, 0, 5169, 5170, + 5, 95, 0, 0, 5170, 5171, 7, 0, 0, 0, 5171, 5172, 7, 17, 0, 0, 5172, 5173, + 7, 11, 0, 0, 5173, 5174, 7, 4, 0, 0, 5174, 5175, 5, 95, 0, 0, 5175, 5176, + 7, 14, 0, 0, 5176, 5177, 7, 4, 0, 0, 5177, 5178, 7, 8, 0, 0, 5178, 5179, + 7, 5, 0, 0, 5179, 5180, 7, 9, 0, 0, 5180, 5181, 7, 3, 0, 0, 5181, 5182, + 7, 11, 0, 0, 5182, 482, 1, 0, 0, 0, 5183, 5184, 7, 1, 0, 0, 5184, 5185, + 7, 6, 0, 0, 5185, 5186, 7, 7, 0, 0, 5186, 5187, 7, 0, 0, 0, 5187, 5188, + 7, 10, 0, 0, 5188, 5189, 7, 20, 0, 0, 5189, 5190, 7, 9, 0, 0, 5190, 5191, + 5, 95, 0, 0, 5191, 5192, 7, 7, 0, 0, 5192, 5193, 7, 8, 0, 0, 5193, 5194, + 7, 4, 0, 0, 5194, 5195, 7, 13, 0, 0, 5195, 5196, 7, 12, 0, 0, 5196, 5197, + 7, 20, 0, 0, 5197, 5198, 7, 0, 0, 0, 5198, 5199, 7, 22, 0, 0, 5199, 5200, + 7, 9, 0, 0, 5200, 5201, 5, 95, 0, 0, 5201, 5202, 7, 1, 0, 0, 5202, 5203, + 7, 0, 0, 0, 5203, 5204, 7, 11, 0, 0, 5204, 5205, 7, 0, 0, 0, 5205, 484, + 1, 0, 0, 0, 5206, 5207, 7, 1, 0, 0, 5207, 5208, 7, 6, 0, 0, 5208, 5209, + 7, 7, 0, 0, 5209, 5210, 7, 22, 0, 0, 5210, 486, 1, 0, 0, 0, 5211, 5212, + 7, 1, 0, 0, 5212, 5213, 7, 6, 0, 0, 5213, 5214, 7, 7, 0, 0, 5214, 5215, + 7, 2, 0, 0, 5215, 5216, 7, 20, 0, 0, 5216, 5217, 7, 0, 0, 0, 5217, 5218, + 7, 18, 0, 0, 5218, 5219, 5, 95, 0, 0, 5219, 5220, 7, 8, 0, 0, 5220, 5221, + 7, 0, 0, 0, 5221, 5222, 7, 19, 0, 0, 5222, 5223, 7, 9, 0, 0, 5223, 488, + 1, 0, 0, 0, 5224, 5225, 7, 1, 0, 0, 5225, 5226, 7, 6, 0, 0, 5226, 5227, + 7, 7, 0, 0, 5227, 5228, 7, 11, 0, 0, 5228, 5229, 7, 6, 0, 0, 5229, 5230, + 7, 8, 0, 0, 5230, 5231, 7, 14, 0, 0, 5231, 5232, 7, 11, 0, 0, 5232, 490, + 1, 0, 0, 0, 5233, 5234, 7, 1, 0, 0, 5234, 5235, 7, 4, 0, 0, 5235, 492, + 1, 0, 0, 0, 5236, 5237, 7, 1, 0, 0, 5237, 5238, 7, 4, 0, 0, 5238, 5239, + 7, 13, 0, 0, 5239, 5240, 7, 8, 0, 0, 5240, 5241, 7, 7, 0, 0, 5241, 5242, + 7, 11, 0, 0, 5242, 5243, 7, 3, 0, 0, 5243, 5244, 7, 9, 0, 0, 5244, 5245, + 7, 0, 0, 0, 5245, 5246, 7, 19, 0, 0, 5246, 494, 1, 0, 0, 0, 5247, 5248, + 7, 1, 0, 0, 5248, 5249, 7, 4, 0, 0, 5249, 5250, 7, 17, 0, 0, 5250, 5251, + 7, 10, 0, 0, 5251, 5252, 7, 20, 0, 0, 5252, 5253, 7, 9, 0, 0, 5253, 496, + 1, 0, 0, 0, 5254, 5255, 7, 1, 0, 0, 5255, 5256, 7, 3, 0, 0, 5256, 5257, + 7, 4, 0, 0, 5257, 5258, 7, 2, 0, 0, 5258, 498, 1, 0, 0, 0, 5259, 5260, + 7, 1, 0, 0, 5260, 5261, 7, 18, 0, 0, 5261, 5262, 7, 8, 0, 0, 5262, 5263, + 7, 0, 0, 0, 5263, 5264, 7, 19, 0, 0, 5264, 5265, 7, 6, 0, 0, 5265, 5266, + 7, 14, 0, 0, 5266, 500, 1, 0, 0, 0, 5267, 5268, 7, 9, 0, 0, 5268, 5269, + 7, 14, 0, 0, 5269, 5270, 7, 4, 0, 0, 5270, 5271, 7, 8, 0, 0, 5271, 5272, + 7, 4, 0, 0, 5272, 5273, 7, 19, 0, 0, 5273, 5274, 7, 18, 0, 0, 5274, 502, + 1, 0, 0, 0, 5275, 5276, 7, 9, 0, 0, 5276, 5277, 7, 1, 0, 0, 5277, 5278, + 7, 6, 0, 0, 5278, 5279, 7, 11, 0, 0, 5279, 5280, 7, 6, 0, 0, 5280, 5281, + 7, 4, 0, 0, 5281, 5282, 7, 8, 0, 0, 5282, 504, 1, 0, 0, 0, 5283, 5284, + 7, 9, 0, 0, 5284, 5285, 7, 20, 0, 0, 5285, 5286, 7, 7, 0, 0, 5286, 5287, + 7, 9, 0, 0, 5287, 506, 1, 0, 0, 0, 5288, 5289, 7, 9, 0, 0, 5289, 5290, + 7, 19, 0, 0, 5290, 5291, 7, 0, 0, 0, 5291, 5292, 7, 6, 0, 0, 5292, 5293, + 7, 20, 0, 0, 5293, 508, 1, 0, 0, 0, 5294, 5295, 7, 9, 0, 0, 5295, 5296, + 7, 19, 0, 0, 5296, 5297, 7, 2, 0, 0, 5297, 5298, 7, 11, 0, 0, 5298, 5299, + 7, 18, 0, 0, 5299, 510, 1, 0, 0, 0, 5300, 5301, 7, 9, 0, 0, 5301, 5302, + 7, 19, 0, 0, 5302, 5303, 7, 2, 0, 0, 5303, 5304, 7, 11, 0, 0, 5304, 5305, + 7, 18, 0, 0, 5305, 5306, 5, 95, 0, 0, 5306, 5307, 7, 12, 0, 0, 5307, 5308, + 7, 6, 0, 0, 5308, 5309, 7, 9, 0, 0, 5309, 5310, 7, 20, 0, 0, 5310, 5311, + 7, 1, 0, 0, 5311, 5312, 5, 95, 0, 0, 5312, 5313, 7, 0, 0, 0, 5313, 5314, + 7, 7, 0, 0, 5314, 5315, 5, 95, 0, 0, 5315, 5316, 7, 8, 0, 0, 5316, 5317, + 7, 17, 0, 0, 5317, 5318, 7, 20, 0, 0, 5318, 5319, 7, 20, 0, 0, 5319, 512, + 1, 0, 0, 0, 5320, 5321, 7, 9, 0, 0, 5321, 5322, 7, 8, 0, 0, 5322, 5323, + 7, 0, 0, 0, 5323, 5324, 7, 10, 0, 0, 5324, 5325, 7, 20, 0, 0, 5325, 5326, + 7, 9, 0, 0, 5326, 514, 1, 0, 0, 0, 5327, 5328, 7, 9, 0, 0, 5328, 5329, + 7, 8, 0, 0, 5329, 5330, 7, 0, 0, 0, 5330, 5331, 7, 10, 0, 0, 5331, 5332, + 7, 20, 0, 0, 5332, 5333, 7, 9, 0, 0, 5333, 5334, 7, 1, 0, 0, 5334, 516, + 1, 0, 0, 0, 5335, 5336, 7, 9, 0, 0, 5336, 5337, 7, 8, 0, 0, 5337, 5338, + 7, 0, 0, 0, 5338, 5339, 7, 10, 0, 0, 5339, 5340, 7, 20, 0, 0, 5340, 5341, + 7, 9, 0, 0, 5341, 5342, 5, 95, 0, 0, 5342, 5343, 7, 12, 0, 0, 5343, 5344, + 7, 4, 0, 0, 5344, 5345, 7, 3, 0, 0, 5345, 5346, 5, 95, 0, 0, 5346, 5347, + 7, 2, 0, 0, 5347, 5348, 7, 3, 0, 0, 5348, 5349, 7, 6, 0, 0, 5349, 5350, + 7, 5, 0, 0, 5350, 5351, 7, 6, 0, 0, 5351, 5352, 7, 20, 0, 0, 5352, 5353, + 7, 9, 0, 0, 5353, 5354, 7, 21, 0, 0, 5354, 5355, 7, 9, 0, 0, 5355, 518, + 1, 0, 0, 0, 5356, 5357, 7, 9, 0, 0, 5357, 5358, 7, 8, 0, 0, 5358, 5359, + 7, 0, 0, 0, 5359, 5360, 7, 10, 0, 0, 5360, 5361, 7, 20, 0, 0, 5361, 5362, + 7, 9, 0, 0, 5362, 5363, 5, 95, 0, 0, 5363, 5364, 7, 6, 0, 0, 5364, 5365, + 7, 8, 0, 0, 5365, 5366, 7, 11, 0, 0, 5366, 5367, 7, 9, 0, 0, 5367, 5368, + 7, 3, 0, 0, 5368, 5369, 7, 8, 0, 0, 5369, 5370, 7, 0, 0, 0, 5370, 5371, + 7, 20, 0, 0, 5371, 5372, 5, 95, 0, 0, 5372, 5373, 7, 7, 0, 0, 5373, 5374, + 7, 11, 0, 0, 5374, 5375, 7, 0, 0, 0, 5375, 5376, 7, 21, 0, 0, 5376, 5377, + 7, 9, 0, 0, 5377, 5378, 7, 7, 0, 0, 5378, 5379, 5, 95, 0, 0, 5379, 5380, + 7, 2, 0, 0, 5380, 5381, 7, 3, 0, 0, 5381, 5382, 7, 6, 0, 0, 5382, 5383, + 7, 5, 0, 0, 5383, 5384, 7, 0, 0, 0, 5384, 5385, 7, 11, 0, 0, 5385, 5386, + 7, 9, 0, 0, 5386, 5387, 7, 20, 0, 0, 5387, 5388, 7, 6, 0, 0, 5388, 5389, + 7, 8, 0, 0, 5389, 5390, 7, 22, 0, 0, 5390, 520, 1, 0, 0, 0, 5391, 5392, + 7, 9, 0, 0, 5392, 5393, 7, 8, 0, 0, 5393, 5394, 7, 0, 0, 0, 5394, 5395, + 7, 10, 0, 0, 5395, 5396, 7, 20, 0, 0, 5396, 5397, 7, 9, 0, 0, 5397, 5398, + 5, 95, 0, 0, 5398, 5399, 7, 4, 0, 0, 5399, 5400, 7, 14, 0, 0, 5400, 5401, + 7, 11, 0, 0, 5401, 5402, 7, 0, 0, 0, 5402, 5403, 7, 20, 0, 0, 5403, 522, + 1, 0, 0, 0, 5404, 5405, 7, 9, 0, 0, 5405, 5406, 7, 8, 0, 0, 5406, 5407, + 7, 0, 0, 0, 5407, 5408, 7, 10, 0, 0, 5408, 5409, 7, 20, 0, 0, 5409, 5410, + 7, 9, 0, 0, 5410, 5411, 5, 95, 0, 0, 5411, 5412, 7, 16, 0, 0, 5412, 5413, + 7, 17, 0, 0, 5413, 5414, 7, 9, 0, 0, 5414, 5415, 7, 3, 0, 0, 5415, 5416, + 7, 18, 0, 0, 5416, 5417, 5, 95, 0, 0, 5417, 5418, 7, 0, 0, 0, 5418, 5419, + 7, 14, 0, 0, 5419, 5420, 7, 14, 0, 0, 5420, 5421, 7, 9, 0, 0, 5421, 5422, + 7, 20, 0, 0, 5422, 5423, 7, 9, 0, 0, 5423, 5424, 7, 3, 0, 0, 5424, 5425, + 7, 0, 0, 0, 5425, 5426, 7, 11, 0, 0, 5426, 5427, 7, 6, 0, 0, 5427, 5428, + 7, 4, 0, 0, 5428, 5429, 7, 8, 0, 0, 5429, 524, 1, 0, 0, 0, 5430, 5431, + 7, 9, 0, 0, 5431, 5432, 7, 8, 0, 0, 5432, 5433, 7, 0, 0, 0, 5433, 5434, + 7, 10, 0, 0, 5434, 5435, 7, 20, 0, 0, 5435, 5436, 7, 9, 0, 0, 5436, 5437, + 5, 95, 0, 0, 5437, 5438, 7, 17, 0, 0, 5438, 5439, 7, 8, 0, 0, 5439, 5440, + 7, 20, 0, 0, 5440, 5441, 7, 4, 0, 0, 5441, 5442, 7, 0, 0, 0, 5442, 5443, + 7, 1, 0, 0, 5443, 5444, 5, 95, 0, 0, 5444, 5445, 7, 2, 0, 0, 5445, 5446, + 7, 15, 0, 0, 5446, 5447, 7, 18, 0, 0, 5447, 5448, 7, 7, 0, 0, 5448, 5449, + 7, 6, 0, 0, 5449, 5450, 7, 14, 0, 0, 5450, 5451, 7, 0, 0, 0, 5451, 5452, + 7, 20, 0, 0, 5452, 5453, 5, 95, 0, 0, 5453, 5454, 7, 11, 0, 0, 5454, 5455, + 7, 18, 0, 0, 5455, 5456, 7, 2, 0, 0, 5456, 5457, 7, 9, 0, 0, 5457, 5458, + 5, 95, 0, 0, 5458, 5459, 7, 4, 0, 0, 5459, 5460, 7, 2, 0, 0, 5460, 5461, + 7, 11, 0, 0, 5461, 5462, 7, 6, 0, 0, 5462, 5463, 7, 19, 0, 0, 5463, 5464, + 7, 6, 0, 0, 5464, 5465, 7, 24, 0, 0, 5465, 5466, 7, 0, 0, 0, 5466, 5467, + 7, 11, 0, 0, 5467, 5468, 7, 6, 0, 0, 5468, 5469, 7, 4, 0, 0, 5469, 5470, + 7, 8, 0, 0, 5470, 526, 1, 0, 0, 0, 5471, 5472, 7, 9, 0, 0, 5472, 5473, + 7, 8, 0, 0, 5473, 5474, 7, 14, 0, 0, 5474, 5475, 7, 4, 0, 0, 5475, 5476, + 7, 1, 0, 0, 5476, 5477, 7, 6, 0, 0, 5477, 5478, 7, 8, 0, 0, 5478, 5479, + 7, 21, 0, 0, 5479, 528, 1, 0, 0, 0, 5480, 5481, 7, 9, 0, 0, 5481, 5482, + 7, 8, 0, 0, 5482, 5483, 7, 14, 0, 0, 5483, 5484, 7, 3, 0, 0, 5484, 5485, + 7, 18, 0, 0, 5485, 5486, 7, 2, 0, 0, 5486, 5487, 7, 11, 0, 0, 5487, 5488, + 7, 6, 0, 0, 5488, 5489, 7, 4, 0, 0, 5489, 5490, 7, 8, 0, 0, 5490, 530, + 1, 0, 0, 0, 5491, 5492, 7, 9, 0, 0, 5492, 5493, 7, 8, 0, 0, 5493, 5494, + 7, 1, 0, 0, 5494, 532, 1, 0, 0, 0, 5495, 5496, 7, 9, 0, 0, 5496, 5497, + 7, 8, 0, 0, 5497, 5498, 7, 1, 0, 0, 5498, 5499, 7, 2, 0, 0, 5499, 5500, + 7, 4, 0, 0, 5500, 5501, 7, 6, 0, 0, 5501, 5502, 7, 8, 0, 0, 5502, 5503, + 7, 11, 0, 0, 5503, 534, 1, 0, 0, 0, 5504, 5505, 7, 9, 0, 0, 5505, 5506, + 7, 8, 0, 0, 5506, 5507, 7, 1, 0, 0, 5507, 5508, 5, 95, 0, 0, 5508, 5509, + 7, 11, 0, 0, 5509, 5510, 7, 6, 0, 0, 5510, 5511, 7, 19, 0, 0, 5511, 5512, + 7, 9, 0, 0, 5512, 5513, 7, 7, 0, 0, 5513, 5514, 7, 11, 0, 0, 5514, 5515, + 7, 0, 0, 0, 5515, 5516, 7, 19, 0, 0, 5516, 5517, 7, 2, 0, 0, 5517, 536, + 1, 0, 0, 0, 5518, 5519, 7, 9, 0, 0, 5519, 5520, 7, 8, 0, 0, 5520, 5521, + 7, 12, 0, 0, 5521, 5522, 7, 4, 0, 0, 5522, 5523, 7, 3, 0, 0, 5523, 5524, + 7, 14, 0, 0, 5524, 5525, 7, 9, 0, 0, 5525, 5526, 7, 1, 0, 0, 5526, 538, + 1, 0, 0, 0, 5527, 5528, 7, 9, 0, 0, 5528, 5529, 7, 8, 0, 0, 5529, 5530, + 7, 12, 0, 0, 5530, 5531, 7, 4, 0, 0, 5531, 5532, 7, 3, 0, 0, 5532, 5533, + 7, 14, 0, 0, 5533, 5534, 7, 9, 0, 0, 5534, 5535, 5, 95, 0, 0, 5535, 5536, + 7, 20, 0, 0, 5536, 5537, 7, 9, 0, 0, 5537, 5538, 7, 8, 0, 0, 5538, 5539, + 7, 21, 0, 0, 5539, 5540, 7, 11, 0, 0, 5540, 5541, 7, 15, 0, 0, 5541, 540, + 1, 0, 0, 0, 5542, 5543, 7, 9, 0, 0, 5543, 5544, 7, 8, 0, 0, 5544, 5545, + 7, 12, 0, 0, 5545, 5546, 7, 4, 0, 0, 5546, 5547, 7, 3, 0, 0, 5547, 5548, + 7, 14, 0, 0, 5548, 5549, 7, 9, 0, 0, 5549, 5550, 5, 95, 0, 0, 5550, 5551, + 7, 7, 0, 0, 5551, 5552, 7, 9, 0, 0, 5552, 5553, 7, 7, 0, 0, 5553, 5554, + 7, 7, 0, 0, 5554, 5555, 7, 6, 0, 0, 5555, 5556, 7, 4, 0, 0, 5556, 5557, + 7, 8, 0, 0, 5557, 5558, 5, 95, 0, 0, 5558, 5559, 7, 2, 0, 0, 5559, 5560, + 7, 4, 0, 0, 5560, 5561, 7, 20, 0, 0, 5561, 5562, 7, 6, 0, 0, 5562, 5563, + 7, 14, 0, 0, 5563, 5564, 7, 18, 0, 0, 5564, 542, 1, 0, 0, 0, 5565, 5566, + 7, 9, 0, 0, 5566, 5567, 7, 8, 0, 0, 5567, 5568, 7, 11, 0, 0, 5568, 5569, + 7, 9, 0, 0, 5569, 5570, 7, 3, 0, 0, 5570, 5571, 7, 2, 0, 0, 5571, 5572, + 7, 3, 0, 0, 5572, 5573, 7, 6, 0, 0, 5573, 5574, 7, 7, 0, 0, 5574, 5575, + 7, 9, 0, 0, 5575, 544, 1, 0, 0, 0, 5576, 5577, 7, 9, 0, 0, 5577, 5578, + 7, 16, 0, 0, 5578, 5579, 7, 17, 0, 0, 5579, 5580, 7, 0, 0, 0, 5580, 5581, + 7, 20, 0, 0, 5581, 5582, 7, 6, 0, 0, 5582, 5583, 7, 11, 0, 0, 5583, 5584, + 7, 18, 0, 0, 5584, 546, 1, 0, 0, 0, 5585, 5586, 7, 9, 0, 0, 5586, 5587, + 7, 3, 0, 0, 5587, 5588, 7, 3, 0, 0, 5588, 5589, 7, 4, 0, 0, 5589, 5590, + 7, 3, 0, 0, 5590, 5591, 5, 95, 0, 0, 5591, 5592, 7, 6, 0, 0, 5592, 5593, + 7, 8, 0, 0, 5593, 5594, 7, 11, 0, 0, 5594, 5595, 7, 9, 0, 0, 5595, 5596, + 7, 21, 0, 0, 5596, 5597, 7, 3, 0, 0, 5597, 5598, 7, 0, 0, 0, 5598, 5599, + 7, 11, 0, 0, 5599, 5600, 7, 6, 0, 0, 5600, 5601, 7, 4, 0, 0, 5601, 5602, + 7, 8, 0, 0, 5602, 548, 1, 0, 0, 0, 5603, 5604, 7, 9, 0, 0, 5604, 5605, + 7, 3, 0, 0, 5605, 5606, 7, 3, 0, 0, 5606, 5607, 7, 4, 0, 0, 5607, 5608, + 7, 3, 0, 0, 5608, 5609, 5, 95, 0, 0, 5609, 5610, 7, 4, 0, 0, 5610, 5611, + 7, 8, 0, 0, 5611, 5612, 5, 95, 0, 0, 5612, 5613, 7, 14, 0, 0, 5613, 5614, + 7, 4, 0, 0, 5614, 5615, 7, 20, 0, 0, 5615, 5616, 7, 17, 0, 0, 5616, 5617, + 7, 19, 0, 0, 5617, 5618, 7, 8, 0, 0, 5618, 5619, 5, 95, 0, 0, 5619, 5620, + 7, 14, 0, 0, 5620, 5621, 7, 4, 0, 0, 5621, 5622, 7, 17, 0, 0, 5622, 5623, + 7, 8, 0, 0, 5623, 5624, 7, 11, 0, 0, 5624, 5625, 5, 95, 0, 0, 5625, 5626, + 7, 19, 0, 0, 5626, 5627, 7, 6, 0, 0, 5627, 5628, 7, 7, 0, 0, 5628, 5629, + 7, 19, 0, 0, 5629, 5630, 7, 0, 0, 0, 5630, 5631, 7, 11, 0, 0, 5631, 5632, + 7, 14, 0, 0, 5632, 5633, 7, 15, 0, 0, 5633, 550, 1, 0, 0, 0, 5634, 5635, + 7, 9, 0, 0, 5635, 5636, 7, 3, 0, 0, 5636, 5637, 7, 3, 0, 0, 5637, 5638, + 7, 4, 0, 0, 5638, 5639, 7, 3, 0, 0, 5639, 5640, 5, 95, 0, 0, 5640, 5641, + 7, 4, 0, 0, 5641, 5642, 7, 8, 0, 0, 5642, 5643, 5, 95, 0, 0, 5643, 5644, + 7, 8, 0, 0, 5644, 5645, 7, 4, 0, 0, 5645, 5646, 7, 8, 0, 0, 5646, 5647, + 7, 1, 0, 0, 5647, 5648, 7, 9, 0, 0, 5648, 5649, 7, 11, 0, 0, 5649, 5650, + 7, 9, 0, 0, 5650, 5651, 7, 3, 0, 0, 5651, 5652, 7, 19, 0, 0, 5652, 5653, + 7, 6, 0, 0, 5653, 5654, 7, 8, 0, 0, 5654, 5655, 7, 6, 0, 0, 5655, 5656, + 7, 7, 0, 0, 5656, 5657, 7, 11, 0, 0, 5657, 5658, 7, 6, 0, 0, 5658, 5659, + 7, 14, 0, 0, 5659, 5660, 5, 95, 0, 0, 5660, 5661, 7, 19, 0, 0, 5661, 5662, + 7, 9, 0, 0, 5662, 5663, 7, 3, 0, 0, 5663, 5664, 7, 21, 0, 0, 5664, 5665, + 7, 9, 0, 0, 5665, 552, 1, 0, 0, 0, 5666, 5667, 7, 9, 0, 0, 5667, 5668, + 7, 3, 0, 0, 5668, 5669, 7, 3, 0, 0, 5669, 5670, 7, 4, 0, 0, 5670, 5671, + 7, 3, 0, 0, 5671, 5672, 5, 95, 0, 0, 5672, 5673, 7, 4, 0, 0, 5673, 5674, + 7, 8, 0, 0, 5674, 5675, 5, 95, 0, 0, 5675, 5676, 7, 8, 0, 0, 5676, 5677, + 7, 4, 0, 0, 5677, 5678, 7, 8, 0, 0, 5678, 5679, 7, 1, 0, 0, 5679, 5680, + 7, 9, 0, 0, 5680, 5681, 7, 11, 0, 0, 5681, 5682, 7, 9, 0, 0, 5682, 5683, + 7, 3, 0, 0, 5683, 5684, 7, 19, 0, 0, 5684, 5685, 7, 6, 0, 0, 5685, 5686, + 7, 8, 0, 0, 5686, 5687, 7, 6, 0, 0, 5687, 5688, 7, 7, 0, 0, 5688, 5689, + 7, 11, 0, 0, 5689, 5690, 7, 6, 0, 0, 5690, 5691, 7, 14, 0, 0, 5691, 5692, + 5, 95, 0, 0, 5692, 5693, 7, 17, 0, 0, 5693, 5694, 7, 2, 0, 0, 5694, 5695, + 7, 1, 0, 0, 5695, 5696, 7, 0, 0, 0, 5696, 5697, 7, 11, 0, 0, 5697, 5698, + 7, 9, 0, 0, 5698, 554, 1, 0, 0, 0, 5699, 5700, 7, 9, 0, 0, 5700, 5701, + 7, 7, 0, 0, 5701, 5702, 7, 14, 0, 0, 5702, 5703, 7, 0, 0, 0, 5703, 5704, + 7, 2, 0, 0, 5704, 5705, 7, 9, 0, 0, 5705, 556, 1, 0, 0, 0, 5706, 5707, + 7, 9, 0, 0, 5707, 5708, 7, 7, 0, 0, 5708, 5709, 7, 14, 0, 0, 5709, 5710, + 7, 0, 0, 0, 5710, 5711, 7, 2, 0, 0, 5711, 5712, 7, 9, 0, 0, 5712, 5713, + 5, 95, 0, 0, 5713, 5714, 7, 17, 0, 0, 5714, 5715, 7, 8, 0, 0, 5715, 5716, + 7, 9, 0, 0, 5716, 5717, 7, 8, 0, 0, 5717, 5718, 7, 14, 0, 0, 5718, 5719, + 7, 20, 0, 0, 5719, 5720, 7, 4, 0, 0, 5720, 5721, 7, 7, 0, 0, 5721, 5722, + 7, 9, 0, 0, 5722, 5723, 7, 1, 0, 0, 5723, 5724, 5, 95, 0, 0, 5724, 5725, + 7, 12, 0, 0, 5725, 5726, 7, 6, 0, 0, 5726, 5727, 7, 9, 0, 0, 5727, 5728, + 7, 20, 0, 0, 5728, 5729, 7, 1, 0, 0, 5729, 558, 1, 0, 0, 0, 5730, 5731, + 7, 9, 0, 0, 5731, 5732, 7, 23, 0, 0, 5732, 5733, 7, 14, 0, 0, 5733, 5734, + 7, 9, 0, 0, 5734, 5735, 7, 2, 0, 0, 5735, 5736, 7, 11, 0, 0, 5736, 560, + 1, 0, 0, 0, 5737, 5738, 7, 9, 0, 0, 5738, 5739, 7, 23, 0, 0, 5739, 5740, + 7, 14, 0, 0, 5740, 5741, 7, 15, 0, 0, 5741, 5742, 7, 0, 0, 0, 5742, 5743, + 7, 8, 0, 0, 5743, 5744, 7, 21, 0, 0, 5744, 5745, 7, 9, 0, 0, 5745, 562, + 1, 0, 0, 0, 5746, 5747, 7, 9, 0, 0, 5747, 5748, 7, 23, 0, 0, 5748, 5749, + 7, 9, 0, 0, 5749, 5750, 7, 14, 0, 0, 5750, 5754, 1, 0, 0, 0, 5751, 5752, + 7, 17, 0, 0, 5752, 5753, 7, 11, 0, 0, 5753, 5755, 7, 9, 0, 0, 5754, 5751, + 1, 0, 0, 0, 5754, 5755, 1, 0, 0, 0, 5755, 564, 1, 0, 0, 0, 5756, 5757, + 7, 9, 0, 0, 5757, 5758, 7, 23, 0, 0, 5758, 5759, 7, 9, 0, 0, 5759, 5760, + 7, 14, 0, 0, 5760, 5761, 7, 17, 0, 0, 5761, 5762, 7, 11, 0, 0, 5762, 5763, + 7, 6, 0, 0, 5763, 5764, 7, 4, 0, 0, 5764, 5765, 7, 8, 0, 0, 5765, 566, + 1, 0, 0, 0, 5766, 5767, 7, 9, 0, 0, 5767, 5768, 7, 23, 0, 0, 5768, 5769, + 7, 6, 0, 0, 5769, 5770, 7, 7, 0, 0, 5770, 5771, 7, 11, 0, 0, 5771, 568, + 1, 0, 0, 0, 5772, 5773, 7, 9, 0, 0, 5773, 5774, 7, 23, 0, 0, 5774, 5775, + 7, 6, 0, 0, 5775, 5776, 7, 7, 0, 0, 5776, 5777, 7, 11, 0, 0, 5777, 5778, + 7, 7, 0, 0, 5778, 570, 1, 0, 0, 0, 5779, 5780, 7, 9, 0, 0, 5780, 5781, + 7, 23, 0, 0, 5781, 5782, 7, 6, 0, 0, 5782, 5783, 7, 11, 0, 0, 5783, 572, + 1, 0, 0, 0, 5784, 5785, 7, 9, 0, 0, 5785, 5786, 7, 23, 0, 0, 5786, 5787, + 7, 2, 0, 0, 5787, 5788, 7, 0, 0, 0, 5788, 5789, 7, 8, 0, 0, 5789, 5790, + 7, 1, 0, 0, 5790, 574, 1, 0, 0, 0, 5791, 5792, 7, 9, 0, 0, 5792, 5793, + 7, 23, 0, 0, 5793, 5794, 7, 2, 0, 0, 5794, 5795, 7, 6, 0, 0, 5795, 5796, + 7, 3, 0, 0, 5796, 5797, 7, 18, 0, 0, 5797, 5798, 5, 95, 0, 0, 5798, 5799, + 7, 1, 0, 0, 5799, 5800, 7, 0, 0, 0, 5800, 5801, 7, 11, 0, 0, 5801, 5802, + 7, 9, 0, 0, 5802, 576, 1, 0, 0, 0, 5803, 5804, 7, 9, 0, 0, 5804, 5805, + 7, 23, 0, 0, 5805, 5806, 7, 2, 0, 0, 5806, 5807, 7, 20, 0, 0, 5807, 5808, + 7, 0, 0, 0, 5808, 5809, 7, 6, 0, 0, 5809, 5810, 7, 8, 0, 0, 5810, 578, + 1, 0, 0, 0, 5811, 5812, 7, 9, 0, 0, 5812, 5813, 7, 23, 0, 0, 5813, 5814, + 7, 2, 0, 0, 5814, 5815, 7, 20, 0, 0, 5815, 5816, 7, 6, 0, 0, 5816, 5817, + 7, 14, 0, 0, 5817, 5818, 7, 6, 0, 0, 5818, 5819, 7, 11, 0, 0, 5819, 580, + 1, 0, 0, 0, 5820, 5821, 7, 9, 0, 0, 5821, 5822, 7, 23, 0, 0, 5822, 5823, + 7, 11, 0, 0, 5823, 5824, 7, 9, 0, 0, 5824, 5825, 7, 3, 0, 0, 5825, 5826, + 7, 8, 0, 0, 5826, 5827, 7, 0, 0, 0, 5827, 5828, 7, 20, 0, 0, 5828, 582, + 1, 0, 0, 0, 5829, 5830, 7, 9, 0, 0, 5830, 5831, 7, 23, 0, 0, 5831, 5832, + 7, 11, 0, 0, 5832, 5833, 7, 9, 0, 0, 5833, 5834, 7, 3, 0, 0, 5834, 5835, + 7, 8, 0, 0, 5835, 5836, 7, 0, 0, 0, 5836, 5837, 7, 20, 0, 0, 5837, 5838, + 5, 95, 0, 0, 5838, 5839, 7, 4, 0, 0, 5839, 5840, 7, 0, 0, 0, 5840, 5841, + 7, 17, 0, 0, 5841, 5842, 7, 11, 0, 0, 5842, 5843, 7, 15, 0, 0, 5843, 584, + 1, 0, 0, 0, 5844, 5845, 7, 9, 0, 0, 5845, 5846, 7, 23, 0, 0, 5846, 5847, + 7, 11, 0, 0, 5847, 5848, 7, 9, 0, 0, 5848, 5849, 7, 3, 0, 0, 5849, 5850, + 7, 8, 0, 0, 5850, 5851, 7, 0, 0, 0, 5851, 5852, 7, 20, 0, 0, 5852, 5853, + 5, 95, 0, 0, 5853, 5854, 7, 4, 0, 0, 5854, 5855, 7, 0, 0, 0, 5855, 5856, + 7, 17, 0, 0, 5856, 5857, 7, 11, 0, 0, 5857, 5858, 7, 15, 0, 0, 5858, 5859, + 5, 95, 0, 0, 5859, 5860, 7, 0, 0, 0, 5860, 5861, 7, 1, 0, 0, 5861, 5862, + 7, 1, 0, 0, 5862, 5863, 5, 95, 0, 0, 5863, 5864, 7, 2, 0, 0, 5864, 5865, + 7, 3, 0, 0, 5865, 5866, 7, 6, 0, 0, 5866, 5867, 7, 5, 0, 0, 5867, 5868, + 7, 6, 0, 0, 5868, 5869, 7, 20, 0, 0, 5869, 5870, 7, 9, 0, 0, 5870, 5871, + 7, 21, 0, 0, 5871, 5872, 7, 9, 0, 0, 5872, 5873, 7, 1, 0, 0, 5873, 5874, + 5, 95, 0, 0, 5874, 5875, 7, 3, 0, 0, 5875, 5876, 7, 4, 0, 0, 5876, 5877, + 7, 20, 0, 0, 5877, 5878, 7, 9, 0, 0, 5878, 5879, 7, 7, 0, 0, 5879, 5880, + 5, 95, 0, 0, 5880, 5881, 7, 11, 0, 0, 5881, 5882, 7, 4, 0, 0, 5882, 5883, + 5, 95, 0, 0, 5883, 5884, 7, 10, 0, 0, 5884, 5885, 7, 20, 0, 0, 5885, 5886, + 7, 4, 0, 0, 5886, 5887, 7, 14, 0, 0, 5887, 5888, 7, 22, 0, 0, 5888, 5889, + 7, 9, 0, 0, 5889, 5890, 7, 1, 0, 0, 5890, 5891, 5, 95, 0, 0, 5891, 5892, + 7, 20, 0, 0, 5892, 5893, 7, 6, 0, 0, 5893, 5894, 7, 7, 0, 0, 5894, 5895, + 7, 11, 0, 0, 5895, 586, 1, 0, 0, 0, 5896, 5897, 7, 9, 0, 0, 5897, 5898, + 7, 23, 0, 0, 5898, 5899, 7, 11, 0, 0, 5899, 5900, 7, 9, 0, 0, 5900, 5901, + 7, 3, 0, 0, 5901, 5902, 7, 8, 0, 0, 5902, 5903, 7, 0, 0, 0, 5903, 5904, + 7, 20, 0, 0, 5904, 5905, 5, 95, 0, 0, 5905, 5906, 7, 4, 0, 0, 5906, 5907, + 7, 0, 0, 0, 5907, 5908, 7, 17, 0, 0, 5908, 5909, 7, 11, 0, 0, 5909, 5910, + 7, 15, 0, 0, 5910, 5911, 5, 95, 0, 0, 5911, 5912, 7, 0, 0, 0, 5912, 5913, + 7, 20, 0, 0, 5913, 5914, 7, 20, 0, 0, 5914, 5915, 7, 4, 0, 0, 5915, 5916, + 7, 13, 0, 0, 5916, 5917, 7, 9, 0, 0, 5917, 5918, 7, 1, 0, 0, 5918, 5919, + 5, 95, 0, 0, 5919, 5920, 7, 3, 0, 0, 5920, 5921, 7, 4, 0, 0, 5921, 5922, + 7, 20, 0, 0, 5922, 5923, 7, 9, 0, 0, 5923, 5924, 7, 7, 0, 0, 5924, 5925, + 5, 95, 0, 0, 5925, 5926, 7, 20, 0, 0, 5926, 5927, 7, 6, 0, 0, 5927, 5928, + 7, 7, 0, 0, 5928, 5929, 7, 11, 0, 0, 5929, 588, 1, 0, 0, 0, 5930, 5931, + 7, 9, 0, 0, 5931, 5932, 7, 23, 0, 0, 5932, 5933, 7, 11, 0, 0, 5933, 5934, + 7, 9, 0, 0, 5934, 5935, 7, 3, 0, 0, 5935, 5936, 7, 8, 0, 0, 5936, 5937, + 7, 0, 0, 0, 5937, 5938, 7, 20, 0, 0, 5938, 5939, 5, 95, 0, 0, 5939, 5940, + 7, 4, 0, 0, 5940, 5941, 7, 0, 0, 0, 5941, 5942, 7, 17, 0, 0, 5942, 5943, + 7, 11, 0, 0, 5943, 5944, 7, 15, 0, 0, 5944, 5945, 5, 95, 0, 0, 5945, 5946, + 7, 0, 0, 0, 5946, 5947, 7, 8, 0, 0, 5947, 5948, 7, 18, 0, 0, 5948, 5949, + 5, 95, 0, 0, 5949, 5950, 7, 3, 0, 0, 5950, 5951, 7, 4, 0, 0, 5951, 5952, + 7, 20, 0, 0, 5952, 5953, 7, 9, 0, 0, 5953, 5954, 5, 95, 0, 0, 5954, 5955, + 7, 19, 0, 0, 5955, 5956, 7, 4, 0, 0, 5956, 5957, 7, 1, 0, 0, 5957, 5958, + 7, 9, 0, 0, 5958, 590, 1, 0, 0, 0, 5959, 5960, 7, 9, 0, 0, 5960, 5961, + 7, 23, 0, 0, 5961, 5962, 7, 11, 0, 0, 5962, 5963, 7, 9, 0, 0, 5963, 5964, + 7, 3, 0, 0, 5964, 5965, 7, 8, 0, 0, 5965, 5966, 7, 0, 0, 0, 5966, 5967, + 7, 20, 0, 0, 5967, 5968, 5, 95, 0, 0, 5968, 5969, 7, 4, 0, 0, 5969, 5970, + 7, 0, 0, 0, 5970, 5971, 7, 17, 0, 0, 5971, 5972, 7, 11, 0, 0, 5972, 5973, + 7, 15, 0, 0, 5973, 5974, 5, 95, 0, 0, 5974, 5975, 7, 0, 0, 0, 5975, 5976, + 7, 17, 0, 0, 5976, 5977, 7, 1, 0, 0, 5977, 5978, 7, 6, 0, 0, 5978, 5979, + 7, 9, 0, 0, 5979, 5980, 7, 8, 0, 0, 5980, 5981, 7, 14, 0, 0, 5981, 5982, + 7, 9, 0, 0, 5982, 5983, 5, 95, 0, 0, 5983, 5984, 7, 20, 0, 0, 5984, 5985, + 7, 6, 0, 0, 5985, 5986, 7, 7, 0, 0, 5986, 5987, 7, 11, 0, 0, 5987, 592, + 1, 0, 0, 0, 5988, 5989, 7, 9, 0, 0, 5989, 5990, 7, 23, 0, 0, 5990, 5991, + 7, 11, 0, 0, 5991, 5992, 7, 9, 0, 0, 5992, 5993, 7, 3, 0, 0, 5993, 5994, + 7, 8, 0, 0, 5994, 5995, 7, 0, 0, 0, 5995, 5996, 7, 20, 0, 0, 5996, 5997, + 5, 95, 0, 0, 5997, 5998, 7, 4, 0, 0, 5998, 5999, 7, 0, 0, 0, 5999, 6000, + 7, 17, 0, 0, 6000, 6001, 7, 11, 0, 0, 6001, 6002, 7, 15, 0, 0, 6002, 6003, + 5, 95, 0, 0, 6003, 6004, 7, 10, 0, 0, 6004, 6005, 7, 20, 0, 0, 6005, 6006, + 7, 4, 0, 0, 6006, 6007, 7, 14, 0, 0, 6007, 6008, 7, 22, 0, 0, 6008, 6009, + 7, 9, 0, 0, 6009, 6010, 7, 1, 0, 0, 6010, 6011, 5, 95, 0, 0, 6011, 6012, + 7, 3, 0, 0, 6012, 6013, 7, 4, 0, 0, 6013, 6014, 7, 20, 0, 0, 6014, 6015, + 7, 9, 0, 0, 6015, 6016, 7, 7, 0, 0, 6016, 6017, 5, 95, 0, 0, 6017, 6018, + 7, 20, 0, 0, 6018, 6019, 7, 6, 0, 0, 6019, 6020, 7, 7, 0, 0, 6020, 6021, + 7, 11, 0, 0, 6021, 594, 1, 0, 0, 0, 6022, 6023, 7, 9, 0, 0, 6023, 6024, + 7, 23, 0, 0, 6024, 6025, 7, 11, 0, 0, 6025, 6026, 7, 9, 0, 0, 6026, 6027, + 7, 3, 0, 0, 6027, 6028, 7, 8, 0, 0, 6028, 6029, 7, 0, 0, 0, 6029, 6030, + 7, 20, 0, 0, 6030, 6031, 5, 95, 0, 0, 6031, 6032, 7, 4, 0, 0, 6032, 6033, + 7, 0, 0, 0, 6033, 6034, 7, 17, 0, 0, 6034, 6035, 7, 11, 0, 0, 6035, 6036, + 7, 15, 0, 0, 6036, 6037, 5, 95, 0, 0, 6037, 6038, 7, 6, 0, 0, 6038, 6039, + 7, 7, 0, 0, 6039, 6040, 7, 7, 0, 0, 6040, 6041, 7, 17, 0, 0, 6041, 6042, + 7, 9, 0, 0, 6042, 6043, 7, 3, 0, 0, 6043, 596, 1, 0, 0, 0, 6044, 6045, + 7, 9, 0, 0, 6045, 6046, 7, 23, 0, 0, 6046, 6047, 7, 11, 0, 0, 6047, 6048, + 7, 9, 0, 0, 6048, 6049, 7, 3, 0, 0, 6049, 6050, 7, 8, 0, 0, 6050, 6051, + 7, 0, 0, 0, 6051, 6052, 7, 20, 0, 0, 6052, 6053, 5, 95, 0, 0, 6053, 6054, + 7, 4, 0, 0, 6054, 6055, 7, 0, 0, 0, 6055, 6056, 7, 17, 0, 0, 6056, 6057, + 7, 11, 0, 0, 6057, 6058, 7, 15, 0, 0, 6058, 6059, 5, 95, 0, 0, 6059, 6060, + 7, 25, 0, 0, 6060, 6061, 7, 13, 0, 0, 6061, 6062, 7, 7, 0, 0, 6062, 6063, + 5, 95, 0, 0, 6063, 6064, 7, 22, 0, 0, 6064, 6065, 7, 9, 0, 0, 6065, 6066, + 7, 18, 0, 0, 6066, 6067, 7, 7, 0, 0, 6067, 6068, 5, 95, 0, 0, 6068, 6069, + 7, 17, 0, 0, 6069, 6070, 7, 3, 0, 0, 6070, 6071, 7, 20, 0, 0, 6071, 598, + 1, 0, 0, 0, 6072, 6073, 7, 9, 0, 0, 6073, 6074, 7, 23, 0, 0, 6074, 6075, + 7, 11, 0, 0, 6075, 6076, 7, 9, 0, 0, 6076, 6077, 7, 3, 0, 0, 6077, 6078, + 7, 8, 0, 0, 6078, 6079, 7, 0, 0, 0, 6079, 6080, 7, 20, 0, 0, 6080, 6081, + 5, 95, 0, 0, 6081, 6082, 7, 4, 0, 0, 6082, 6083, 7, 0, 0, 0, 6083, 6084, + 7, 17, 0, 0, 6084, 6085, 7, 11, 0, 0, 6085, 6086, 7, 15, 0, 0, 6086, 6087, + 5, 95, 0, 0, 6087, 6088, 7, 3, 0, 0, 6088, 6089, 7, 7, 0, 0, 6089, 6090, + 7, 0, 0, 0, 6090, 6091, 5, 95, 0, 0, 6091, 6092, 7, 2, 0, 0, 6092, 6093, + 7, 17, 0, 0, 6093, 6094, 7, 10, 0, 0, 6094, 6095, 7, 20, 0, 0, 6095, 6096, + 7, 6, 0, 0, 6096, 6097, 7, 14, 0, 0, 6097, 6098, 5, 95, 0, 0, 6098, 6099, + 7, 22, 0, 0, 6099, 6100, 7, 9, 0, 0, 6100, 6101, 7, 18, 0, 0, 6101, 600, + 1, 0, 0, 0, 6102, 6103, 7, 9, 0, 0, 6103, 6104, 7, 23, 0, 0, 6104, 6105, + 7, 11, 0, 0, 6105, 6106, 7, 9, 0, 0, 6106, 6107, 7, 3, 0, 0, 6107, 6108, + 7, 8, 0, 0, 6108, 6109, 7, 0, 0, 0, 6109, 6110, 7, 20, 0, 0, 6110, 6111, + 5, 95, 0, 0, 6111, 6112, 7, 4, 0, 0, 6112, 6113, 7, 0, 0, 0, 6113, 6114, + 7, 17, 0, 0, 6114, 6115, 7, 11, 0, 0, 6115, 6116, 7, 15, 0, 0, 6116, 6117, + 5, 95, 0, 0, 6117, 6118, 7, 3, 0, 0, 6118, 6119, 7, 7, 0, 0, 6119, 6120, + 7, 0, 0, 0, 6120, 6121, 5, 95, 0, 0, 6121, 6122, 7, 2, 0, 0, 6122, 6123, + 7, 17, 0, 0, 6123, 6124, 7, 10, 0, 0, 6124, 6125, 7, 20, 0, 0, 6125, 6126, + 7, 6, 0, 0, 6126, 6127, 7, 14, 0, 0, 6127, 6128, 5, 95, 0, 0, 6128, 6129, + 7, 22, 0, 0, 6129, 6130, 7, 9, 0, 0, 6130, 6131, 7, 18, 0, 0, 6131, 6132, + 5, 95, 0, 0, 6132, 6133, 5, 50, 0, 0, 6133, 602, 1, 0, 0, 0, 6134, 6135, + 7, 9, 0, 0, 6135, 6136, 7, 23, 0, 0, 6136, 6137, 7, 11, 0, 0, 6137, 6138, + 7, 9, 0, 0, 6138, 6139, 7, 3, 0, 0, 6139, 6140, 7, 8, 0, 0, 6140, 6141, + 7, 0, 0, 0, 6141, 6142, 7, 20, 0, 0, 6142, 6143, 5, 95, 0, 0, 6143, 6144, + 7, 4, 0, 0, 6144, 6145, 7, 0, 0, 0, 6145, 6146, 7, 17, 0, 0, 6146, 6147, + 7, 11, 0, 0, 6147, 6148, 7, 15, 0, 0, 6148, 6149, 5, 95, 0, 0, 6149, 6150, + 7, 7, 0, 0, 6150, 6151, 7, 14, 0, 0, 6151, 6152, 7, 4, 0, 0, 6152, 6153, + 7, 2, 0, 0, 6153, 6154, 7, 9, 0, 0, 6154, 6155, 5, 95, 0, 0, 6155, 6156, + 7, 1, 0, 0, 6156, 6157, 7, 9, 0, 0, 6157, 6158, 7, 20, 0, 0, 6158, 6159, + 7, 6, 0, 0, 6159, 6160, 7, 19, 0, 0, 6160, 6161, 7, 6, 0, 0, 6161, 6162, + 7, 11, 0, 0, 6162, 6163, 7, 9, 0, 0, 6163, 6164, 7, 3, 0, 0, 6164, 604, + 1, 0, 0, 0, 6165, 6166, 7, 9, 0, 0, 6166, 6167, 7, 23, 0, 0, 6167, 6168, + 7, 11, 0, 0, 6168, 6169, 7, 9, 0, 0, 6169, 6170, 7, 3, 0, 0, 6170, 6171, + 7, 8, 0, 0, 6171, 6172, 7, 0, 0, 0, 6172, 6173, 7, 20, 0, 0, 6173, 6174, + 5, 95, 0, 0, 6174, 6175, 7, 4, 0, 0, 6175, 6176, 7, 0, 0, 0, 6176, 6177, + 7, 17, 0, 0, 6177, 6178, 7, 11, 0, 0, 6178, 6179, 7, 15, 0, 0, 6179, 6180, + 5, 95, 0, 0, 6180, 6181, 7, 7, 0, 0, 6181, 6182, 7, 8, 0, 0, 6182, 6183, + 7, 4, 0, 0, 6183, 6184, 7, 13, 0, 0, 6184, 6185, 7, 12, 0, 0, 6185, 6186, + 7, 20, 0, 0, 6186, 6187, 7, 0, 0, 0, 6187, 6188, 7, 22, 0, 0, 6188, 6189, + 7, 9, 0, 0, 6189, 6190, 5, 95, 0, 0, 6190, 6191, 7, 17, 0, 0, 6191, 6192, + 7, 7, 0, 0, 6192, 6193, 7, 9, 0, 0, 6193, 6194, 7, 3, 0, 0, 6194, 6195, + 5, 95, 0, 0, 6195, 6196, 7, 19, 0, 0, 6196, 6197, 7, 0, 0, 0, 6197, 6198, + 7, 2, 0, 0, 6198, 6199, 7, 2, 0, 0, 6199, 6200, 7, 6, 0, 0, 6200, 6201, + 7, 8, 0, 0, 6201, 6202, 7, 21, 0, 0, 6202, 6203, 5, 95, 0, 0, 6203, 6204, + 7, 0, 0, 0, 6204, 6205, 7, 11, 0, 0, 6205, 6206, 7, 11, 0, 0, 6206, 6207, + 7, 3, 0, 0, 6207, 6208, 7, 6, 0, 0, 6208, 6209, 7, 10, 0, 0, 6209, 6210, + 7, 17, 0, 0, 6210, 6211, 7, 11, 0, 0, 6211, 6212, 7, 9, 0, 0, 6212, 606, + 1, 0, 0, 0, 6213, 6214, 7, 9, 0, 0, 6214, 6215, 7, 23, 0, 0, 6215, 6216, + 7, 11, 0, 0, 6216, 6217, 7, 9, 0, 0, 6217, 6218, 7, 3, 0, 0, 6218, 6219, + 7, 8, 0, 0, 6219, 6220, 7, 0, 0, 0, 6220, 6221, 7, 20, 0, 0, 6221, 6222, + 5, 95, 0, 0, 6222, 6223, 7, 4, 0, 0, 6223, 6224, 7, 0, 0, 0, 6224, 6225, + 7, 17, 0, 0, 6225, 6226, 7, 11, 0, 0, 6226, 6227, 7, 15, 0, 0, 6227, 6228, + 5, 95, 0, 0, 6228, 6229, 7, 11, 0, 0, 6229, 6230, 7, 4, 0, 0, 6230, 6231, + 7, 22, 0, 0, 6231, 6232, 7, 9, 0, 0, 6232, 6233, 7, 8, 0, 0, 6233, 6234, + 5, 95, 0, 0, 6234, 6235, 7, 17, 0, 0, 6235, 6236, 7, 7, 0, 0, 6236, 6237, + 7, 9, 0, 0, 6237, 6238, 7, 3, 0, 0, 6238, 6239, 5, 95, 0, 0, 6239, 6240, + 7, 19, 0, 0, 6240, 6241, 7, 0, 0, 0, 6241, 6242, 7, 2, 0, 0, 6242, 6243, + 7, 2, 0, 0, 6243, 6244, 7, 6, 0, 0, 6244, 6245, 7, 8, 0, 0, 6245, 6246, + 7, 21, 0, 0, 6246, 6247, 5, 95, 0, 0, 6247, 6248, 7, 14, 0, 0, 6248, 6249, + 7, 20, 0, 0, 6249, 6250, 7, 0, 0, 0, 6250, 6251, 7, 6, 0, 0, 6251, 6252, + 7, 19, 0, 0, 6252, 608, 1, 0, 0, 0, 6253, 6254, 7, 9, 0, 0, 6254, 6255, + 7, 23, 0, 0, 6255, 6256, 7, 11, 0, 0, 6256, 6257, 7, 9, 0, 0, 6257, 6258, + 7, 3, 0, 0, 6258, 6259, 7, 8, 0, 0, 6259, 6260, 7, 0, 0, 0, 6260, 6261, + 7, 20, 0, 0, 6261, 6262, 5, 95, 0, 0, 6262, 6263, 7, 4, 0, 0, 6263, 6264, + 7, 0, 0, 0, 6264, 6265, 7, 17, 0, 0, 6265, 6266, 7, 11, 0, 0, 6266, 6267, + 7, 15, 0, 0, 6267, 6268, 5, 95, 0, 0, 6268, 6269, 7, 11, 0, 0, 6269, 6270, + 7, 18, 0, 0, 6270, 6271, 7, 2, 0, 0, 6271, 6272, 7, 9, 0, 0, 6272, 610, + 1, 0, 0, 0, 6273, 6274, 7, 9, 0, 0, 6274, 6275, 7, 23, 0, 0, 6275, 6276, + 7, 11, 0, 0, 6276, 6277, 7, 9, 0, 0, 6277, 6278, 7, 3, 0, 0, 6278, 6279, + 7, 8, 0, 0, 6279, 6280, 7, 0, 0, 0, 6280, 6281, 7, 20, 0, 0, 6281, 6282, + 5, 95, 0, 0, 6282, 6283, 7, 7, 0, 0, 6283, 6284, 7, 11, 0, 0, 6284, 6285, + 7, 0, 0, 0, 6285, 6286, 7, 21, 0, 0, 6286, 6287, 7, 9, 0, 0, 6287, 612, + 1, 0, 0, 0, 6288, 6289, 7, 12, 0, 0, 6289, 6290, 7, 0, 0, 0, 6290, 6291, + 7, 6, 0, 0, 6291, 6292, 7, 20, 0, 0, 6292, 6293, 7, 4, 0, 0, 6293, 6294, + 7, 5, 0, 0, 6294, 6295, 7, 9, 0, 0, 6295, 6296, 7, 3, 0, 0, 6296, 614, + 1, 0, 0, 0, 6297, 6298, 7, 12, 0, 0, 6298, 6299, 7, 0, 0, 0, 6299, 6300, + 7, 6, 0, 0, 6300, 6301, 7, 20, 0, 0, 6301, 6302, 7, 4, 0, 0, 6302, 6303, + 7, 5, 0, 0, 6303, 6304, 7, 9, 0, 0, 6304, 6305, 7, 3, 0, 0, 6305, 6306, + 5, 95, 0, 0, 6306, 6307, 7, 19, 0, 0, 6307, 6308, 7, 4, 0, 0, 6308, 6309, + 7, 1, 0, 0, 6309, 6310, 7, 9, 0, 0, 6310, 616, 1, 0, 0, 0, 6311, 6312, + 7, 12, 0, 0, 6312, 6313, 7, 0, 0, 0, 6313, 6314, 7, 6, 0, 0, 6314, 6315, + 7, 20, 0, 0, 6315, 6316, 5, 95, 0, 0, 6316, 6317, 7, 4, 0, 0, 6317, 6318, + 7, 2, 0, 0, 6318, 6319, 7, 9, 0, 0, 6319, 6320, 7, 3, 0, 0, 6320, 6321, + 7, 0, 0, 0, 6321, 6322, 7, 11, 0, 0, 6322, 6323, 7, 6, 0, 0, 6323, 6324, + 7, 4, 0, 0, 6324, 6325, 7, 8, 0, 0, 6325, 618, 1, 0, 0, 0, 6326, 6327, + 7, 12, 0, 0, 6327, 6328, 7, 0, 0, 0, 6328, 6329, 7, 20, 0, 0, 6329, 6330, + 7, 7, 0, 0, 6330, 6331, 7, 9, 0, 0, 6331, 620, 1, 0, 0, 0, 6332, 6333, + 7, 12, 0, 0, 6333, 6334, 7, 9, 0, 0, 6334, 6335, 7, 11, 0, 0, 6335, 6336, + 7, 14, 0, 0, 6336, 6337, 7, 15, 0, 0, 6337, 622, 1, 0, 0, 0, 6338, 6339, + 7, 12, 0, 0, 6339, 6340, 7, 6, 0, 0, 6340, 6341, 7, 9, 0, 0, 6341, 6342, + 7, 20, 0, 0, 6342, 6343, 7, 1, 0, 0, 6343, 6344, 5, 95, 0, 0, 6344, 6345, + 7, 1, 0, 0, 6345, 6346, 7, 9, 0, 0, 6346, 6347, 7, 20, 0, 0, 6347, 6348, + 7, 6, 0, 0, 6348, 6349, 7, 19, 0, 0, 6349, 6350, 7, 6, 0, 0, 6350, 6351, + 7, 11, 0, 0, 6351, 6352, 7, 9, 0, 0, 6352, 6353, 7, 3, 0, 0, 6353, 624, + 1, 0, 0, 0, 6354, 6355, 7, 12, 0, 0, 6355, 6356, 7, 6, 0, 0, 6356, 6357, + 7, 9, 0, 0, 6357, 6358, 7, 20, 0, 0, 6358, 6359, 7, 1, 0, 0, 6359, 6360, + 5, 95, 0, 0, 6360, 6361, 7, 4, 0, 0, 6361, 6362, 7, 2, 0, 0, 6362, 6363, + 7, 11, 0, 0, 6363, 6364, 7, 6, 0, 0, 6364, 6365, 7, 4, 0, 0, 6365, 6366, + 7, 8, 0, 0, 6366, 6367, 7, 0, 0, 0, 6367, 6368, 7, 20, 0, 0, 6368, 6369, + 7, 20, 0, 0, 6369, 6370, 7, 18, 0, 0, 6370, 6371, 5, 95, 0, 0, 6371, 6372, + 7, 9, 0, 0, 6372, 6373, 7, 8, 0, 0, 6373, 6374, 7, 14, 0, 0, 6374, 6375, + 7, 20, 0, 0, 6375, 6376, 7, 4, 0, 0, 6376, 6377, 7, 7, 0, 0, 6377, 6378, + 7, 9, 0, 0, 6378, 6379, 7, 1, 0, 0, 6379, 6380, 5, 95, 0, 0, 6380, 6381, + 7, 10, 0, 0, 6381, 6382, 7, 18, 0, 0, 6382, 626, 1, 0, 0, 0, 6383, 6384, + 7, 12, 0, 0, 6384, 6385, 7, 6, 0, 0, 6385, 6386, 7, 20, 0, 0, 6386, 6387, + 7, 9, 0, 0, 6387, 628, 1, 0, 0, 0, 6388, 6389, 7, 12, 0, 0, 6389, 6390, + 7, 6, 0, 0, 6390, 6391, 7, 20, 0, 0, 6391, 6392, 7, 9, 0, 0, 6392, 6393, + 7, 7, 0, 0, 6393, 630, 1, 0, 0, 0, 6394, 6395, 7, 12, 0, 0, 6395, 6396, + 7, 6, 0, 0, 6396, 6397, 7, 20, 0, 0, 6397, 6398, 7, 9, 0, 0, 6398, 6399, + 5, 95, 0, 0, 6399, 6400, 7, 9, 0, 0, 6400, 6401, 7, 23, 0, 0, 6401, 6402, + 7, 11, 0, 0, 6402, 6403, 7, 9, 0, 0, 6403, 6404, 7, 8, 0, 0, 6404, 6405, + 7, 7, 0, 0, 6405, 6406, 7, 6, 0, 0, 6406, 6407, 7, 4, 0, 0, 6407, 6408, + 7, 8, 0, 0, 6408, 632, 1, 0, 0, 0, 6409, 6410, 7, 12, 0, 0, 6410, 6411, + 7, 6, 0, 0, 6411, 6412, 7, 20, 0, 0, 6412, 6413, 7, 9, 0, 0, 6413, 6414, + 5, 95, 0, 0, 6414, 6415, 7, 12, 0, 0, 6415, 6416, 7, 4, 0, 0, 6416, 6417, + 7, 3, 0, 0, 6417, 6418, 7, 19, 0, 0, 6418, 6419, 7, 0, 0, 0, 6419, 6420, + 7, 11, 0, 0, 6420, 634, 1, 0, 0, 0, 6421, 6422, 7, 12, 0, 0, 6422, 6423, + 7, 6, 0, 0, 6423, 6424, 7, 20, 0, 0, 6424, 6425, 7, 11, 0, 0, 6425, 6426, + 7, 9, 0, 0, 6426, 6427, 7, 3, 0, 0, 6427, 636, 1, 0, 0, 0, 6428, 6429, + 7, 12, 0, 0, 6429, 6430, 7, 6, 0, 0, 6430, 6431, 7, 3, 0, 0, 6431, 6432, + 7, 7, 0, 0, 6432, 6433, 7, 11, 0, 0, 6433, 638, 1, 0, 0, 0, 6434, 6435, + 7, 12, 0, 0, 6435, 6436, 7, 6, 0, 0, 6436, 6437, 7, 3, 0, 0, 6437, 6438, + 7, 7, 0, 0, 6438, 6439, 7, 11, 0, 0, 6439, 6440, 5, 95, 0, 0, 6440, 6441, + 7, 8, 0, 0, 6441, 6442, 7, 0, 0, 0, 6442, 6443, 7, 19, 0, 0, 6443, 6444, + 7, 9, 0, 0, 6444, 640, 1, 0, 0, 0, 6445, 6446, 7, 12, 0, 0, 6446, 6447, + 7, 20, 0, 0, 6447, 6448, 7, 0, 0, 0, 6448, 6449, 7, 11, 0, 0, 6449, 6450, + 7, 11, 0, 0, 6450, 6451, 7, 9, 0, 0, 6451, 6452, 7, 8, 0, 0, 6452, 642, + 1, 0, 0, 0, 6453, 6454, 7, 12, 0, 0, 6454, 6455, 7, 4, 0, 0, 6455, 6456, + 7, 3, 0, 0, 6456, 644, 1, 0, 0, 0, 6457, 6458, 7, 12, 0, 0, 6458, 6459, + 7, 4, 0, 0, 6459, 6460, 7, 3, 0, 0, 6460, 6461, 7, 14, 0, 0, 6461, 6462, + 7, 9, 0, 0, 6462, 646, 1, 0, 0, 0, 6463, 6464, 7, 12, 0, 0, 6464, 6465, + 7, 4, 0, 0, 6465, 6466, 7, 3, 0, 0, 6466, 6467, 7, 9, 0, 0, 6467, 6468, + 7, 6, 0, 0, 6468, 6469, 7, 21, 0, 0, 6469, 6470, 7, 8, 0, 0, 6470, 648, + 1, 0, 0, 0, 6471, 6472, 7, 12, 0, 0, 6472, 6473, 7, 4, 0, 0, 6473, 6474, + 7, 3, 0, 0, 6474, 6475, 7, 19, 0, 0, 6475, 6476, 7, 0, 0, 0, 6476, 6477, + 7, 11, 0, 0, 6477, 650, 1, 0, 0, 0, 6478, 6479, 7, 12, 0, 0, 6479, 6480, + 7, 4, 0, 0, 6480, 6481, 7, 3, 0, 0, 6481, 6482, 7, 19, 0, 0, 6482, 6483, + 7, 0, 0, 0, 6483, 6484, 7, 11, 0, 0, 6484, 6485, 7, 7, 0, 0, 6485, 652, + 1, 0, 0, 0, 6486, 6487, 7, 12, 0, 0, 6487, 6488, 7, 4, 0, 0, 6488, 6489, + 7, 3, 0, 0, 6489, 6490, 7, 19, 0, 0, 6490, 6491, 7, 0, 0, 0, 6491, 6492, + 7, 11, 0, 0, 6492, 6493, 5, 95, 0, 0, 6493, 6494, 7, 8, 0, 0, 6494, 6495, + 7, 0, 0, 0, 6495, 6496, 7, 19, 0, 0, 6496, 6497, 7, 9, 0, 0, 6497, 654, + 1, 0, 0, 0, 6498, 6499, 7, 12, 0, 0, 6499, 6500, 7, 3, 0, 0, 6500, 6501, + 7, 9, 0, 0, 6501, 6502, 7, 16, 0, 0, 6502, 6503, 7, 17, 0, 0, 6503, 6504, + 7, 9, 0, 0, 6504, 6505, 7, 8, 0, 0, 6505, 6506, 7, 14, 0, 0, 6506, 6507, + 7, 18, 0, 0, 6507, 656, 1, 0, 0, 0, 6508, 6509, 7, 12, 0, 0, 6509, 6510, + 7, 3, 0, 0, 6510, 6511, 7, 4, 0, 0, 6511, 6512, 7, 19, 0, 0, 6512, 658, + 1, 0, 0, 0, 6513, 6514, 7, 12, 0, 0, 6514, 6515, 7, 17, 0, 0, 6515, 6516, + 7, 20, 0, 0, 6516, 6517, 7, 20, 0, 0, 6517, 660, 1, 0, 0, 0, 6518, 6519, + 7, 12, 0, 0, 6519, 6520, 7, 17, 0, 0, 6520, 6521, 7, 8, 0, 0, 6521, 6522, + 7, 14, 0, 0, 6522, 6523, 7, 11, 0, 0, 6523, 6524, 7, 6, 0, 0, 6524, 6525, + 7, 4, 0, 0, 6525, 6526, 7, 8, 0, 0, 6526, 662, 1, 0, 0, 0, 6527, 6528, + 7, 12, 0, 0, 6528, 6529, 7, 17, 0, 0, 6529, 6530, 7, 8, 0, 0, 6530, 6531, + 7, 14, 0, 0, 6531, 6532, 7, 11, 0, 0, 6532, 6533, 7, 6, 0, 0, 6533, 6534, + 7, 4, 0, 0, 6534, 6535, 7, 8, 0, 0, 6535, 6536, 7, 7, 0, 0, 6536, 664, + 1, 0, 0, 0, 6537, 6538, 7, 12, 0, 0, 6538, 6539, 7, 17, 0, 0, 6539, 6540, + 7, 11, 0, 0, 6540, 6541, 7, 17, 0, 0, 6541, 6542, 7, 3, 0, 0, 6542, 6543, + 7, 9, 0, 0, 6543, 666, 1, 0, 0, 0, 6544, 6545, 7, 21, 0, 0, 6545, 6546, + 7, 14, 0, 0, 6546, 6547, 7, 2, 0, 0, 6547, 6548, 5, 95, 0, 0, 6548, 6549, + 7, 2, 0, 0, 6549, 6550, 7, 17, 0, 0, 6550, 6551, 7, 10, 0, 0, 6551, 6552, + 7, 7, 0, 0, 6552, 6553, 7, 17, 0, 0, 6553, 6554, 7, 10, 0, 0, 6554, 668, + 1, 0, 0, 0, 6555, 6556, 7, 21, 0, 0, 6556, 6557, 7, 14, 0, 0, 6557, 6558, + 7, 2, 0, 0, 6558, 6559, 5, 95, 0, 0, 6559, 6560, 7, 2, 0, 0, 6560, 6561, + 7, 17, 0, 0, 6561, 6562, 7, 10, 0, 0, 6562, 6563, 7, 7, 0, 0, 6563, 6564, + 7, 17, 0, 0, 6564, 6565, 7, 10, 0, 0, 6565, 6566, 5, 95, 0, 0, 6566, 6567, + 7, 7, 0, 0, 6567, 6568, 7, 17, 0, 0, 6568, 6569, 7, 10, 0, 0, 6569, 6570, + 7, 7, 0, 0, 6570, 6571, 7, 14, 0, 0, 6571, 6572, 7, 3, 0, 0, 6572, 6573, + 7, 6, 0, 0, 6573, 6574, 7, 2, 0, 0, 6574, 6575, 7, 11, 0, 0, 6575, 6576, + 7, 6, 0, 0, 6576, 6577, 7, 4, 0, 0, 6577, 6578, 7, 8, 0, 0, 6578, 6579, + 5, 95, 0, 0, 6579, 6580, 7, 8, 0, 0, 6580, 6581, 7, 0, 0, 0, 6581, 6582, + 7, 19, 0, 0, 6582, 6583, 7, 9, 0, 0, 6583, 670, 1, 0, 0, 0, 6584, 6585, + 7, 21, 0, 0, 6585, 6586, 7, 14, 0, 0, 6586, 6587, 7, 2, 0, 0, 6587, 6588, + 5, 95, 0, 0, 6588, 6589, 7, 2, 0, 0, 6589, 6590, 7, 17, 0, 0, 6590, 6591, + 7, 10, 0, 0, 6591, 6592, 7, 7, 0, 0, 6592, 6593, 7, 17, 0, 0, 6593, 6594, + 7, 10, 0, 0, 6594, 6595, 5, 95, 0, 0, 6595, 6596, 7, 11, 0, 0, 6596, 6597, + 7, 4, 0, 0, 6597, 6598, 7, 2, 0, 0, 6598, 6599, 7, 6, 0, 0, 6599, 6600, + 7, 14, 0, 0, 6600, 6601, 5, 95, 0, 0, 6601, 6602, 7, 8, 0, 0, 6602, 6603, + 7, 0, 0, 0, 6603, 6604, 7, 19, 0, 0, 6604, 6605, 7, 9, 0, 0, 6605, 672, + 1, 0, 0, 0, 6606, 6607, 7, 21, 0, 0, 6607, 6608, 7, 14, 0, 0, 6608, 6609, + 7, 7, 0, 0, 6609, 674, 1, 0, 0, 0, 6610, 6611, 5, 39, 0, 0, 6611, 6612, + 7, 21, 0, 0, 6612, 6613, 7, 9, 0, 0, 6613, 6614, 7, 8, 0, 0, 6614, 6615, + 7, 9, 0, 0, 6615, 6616, 7, 3, 0, 0, 6616, 6617, 7, 6, 0, 0, 6617, 6618, + 7, 14, 0, 0, 6618, 6619, 5, 39, 0, 0, 6619, 676, 1, 0, 0, 0, 6620, 6621, + 5, 39, 0, 0, 6621, 6622, 7, 21, 0, 0, 6622, 6623, 7, 9, 0, 0, 6623, 6624, + 7, 8, 0, 0, 6624, 6625, 7, 9, 0, 0, 6625, 6626, 7, 3, 0, 0, 6626, 6627, + 7, 6, 0, 0, 6627, 6628, 7, 14, 0, 0, 6628, 6629, 5, 95, 0, 0, 6629, 6630, + 7, 7, 0, 0, 6630, 6631, 7, 14, 0, 0, 6631, 6632, 7, 6, 0, 0, 6632, 6633, + 7, 19, 0, 0, 6633, 6634, 5, 95, 0, 0, 6634, 6635, 7, 2, 0, 0, 6635, 6636, + 7, 3, 0, 0, 6636, 6637, 7, 4, 0, 0, 6637, 6638, 7, 5, 0, 0, 6638, 6639, + 7, 6, 0, 0, 6639, 6640, 7, 7, 0, 0, 6640, 6641, 7, 6, 0, 0, 6641, 6642, + 7, 4, 0, 0, 6642, 6643, 7, 8, 0, 0, 6643, 6644, 7, 9, 0, 0, 6644, 6645, + 7, 3, 0, 0, 6645, 6646, 5, 39, 0, 0, 6646, 678, 1, 0, 0, 0, 6647, 6648, + 7, 21, 0, 0, 6648, 6649, 7, 9, 0, 0, 6649, 6650, 7, 4, 0, 0, 6650, 680, + 1, 0, 0, 0, 6651, 6652, 7, 21, 0, 0, 6652, 6653, 7, 9, 0, 0, 6653, 6654, + 7, 4, 0, 0, 6654, 6655, 7, 21, 0, 0, 6655, 6656, 7, 3, 0, 0, 6656, 6657, + 7, 0, 0, 0, 6657, 6658, 7, 2, 0, 0, 6658, 6659, 7, 15, 0, 0, 6659, 6660, + 7, 18, 0, 0, 6660, 6661, 5, 95, 0, 0, 6661, 6662, 7, 4, 0, 0, 6662, 6663, + 7, 17, 0, 0, 6663, 6664, 7, 11, 0, 0, 6664, 6665, 7, 2, 0, 0, 6665, 6666, + 7, 17, 0, 0, 6666, 6667, 7, 11, 0, 0, 6667, 6668, 5, 95, 0, 0, 6668, 6669, + 7, 12, 0, 0, 6669, 6670, 7, 4, 0, 0, 6670, 6671, 7, 3, 0, 0, 6671, 6672, + 7, 19, 0, 0, 6672, 6673, 7, 0, 0, 0, 6673, 6674, 7, 11, 0, 0, 6674, 682, + 1, 0, 0, 0, 6675, 6676, 7, 21, 0, 0, 6676, 6677, 7, 9, 0, 0, 6677, 6678, + 7, 4, 0, 0, 6678, 6679, 7, 19, 0, 0, 6679, 6680, 7, 9, 0, 0, 6680, 6681, + 7, 11, 0, 0, 6681, 6682, 7, 3, 0, 0, 6682, 6683, 7, 18, 0, 0, 6683, 6684, + 5, 95, 0, 0, 6684, 6685, 7, 4, 0, 0, 6685, 6686, 7, 17, 0, 0, 6686, 6687, + 7, 11, 0, 0, 6687, 6688, 7, 2, 0, 0, 6688, 6689, 7, 17, 0, 0, 6689, 6690, + 7, 11, 0, 0, 6690, 6691, 5, 95, 0, 0, 6691, 6692, 7, 12, 0, 0, 6692, 6693, + 7, 4, 0, 0, 6693, 6694, 7, 3, 0, 0, 6694, 6695, 7, 19, 0, 0, 6695, 6696, + 7, 0, 0, 0, 6696, 6697, 7, 11, 0, 0, 6697, 684, 1, 0, 0, 0, 6698, 6699, + 7, 21, 0, 0, 6699, 6700, 7, 9, 0, 0, 6700, 6701, 7, 11, 0, 0, 6701, 686, + 1, 0, 0, 0, 6702, 6703, 7, 21, 0, 0, 6703, 6704, 7, 9, 0, 0, 6704, 6705, + 7, 11, 0, 0, 6705, 6706, 5, 95, 0, 0, 6706, 6707, 7, 12, 0, 0, 6707, 6708, + 7, 6, 0, 0, 6708, 6709, 7, 20, 0, 0, 6709, 6710, 7, 9, 0, 0, 6710, 6711, + 7, 7, 0, 0, 6711, 6712, 7, 11, 0, 0, 6712, 6713, 7, 3, 0, 0, 6713, 6714, + 7, 9, 0, 0, 6714, 6715, 7, 0, 0, 0, 6715, 6716, 7, 19, 0, 0, 6716, 6717, + 5, 95, 0, 0, 6717, 6718, 7, 11, 0, 0, 6718, 6719, 7, 3, 0, 0, 6719, 6720, + 7, 0, 0, 0, 6720, 6721, 7, 8, 0, 0, 6721, 6722, 7, 7, 0, 0, 6722, 6723, + 7, 0, 0, 0, 6723, 6724, 7, 14, 0, 0, 6724, 6725, 7, 11, 0, 0, 6725, 6726, + 7, 6, 0, 0, 6726, 6727, 7, 4, 0, 0, 6727, 6728, 7, 8, 0, 0, 6728, 6729, + 5, 95, 0, 0, 6729, 6730, 7, 14, 0, 0, 6730, 6731, 7, 4, 0, 0, 6731, 6732, + 7, 8, 0, 0, 6732, 6733, 7, 11, 0, 0, 6733, 6734, 7, 9, 0, 0, 6734, 6735, + 7, 23, 0, 0, 6735, 6736, 7, 11, 0, 0, 6736, 688, 1, 0, 0, 0, 6737, 6738, + 7, 21, 0, 0, 6738, 6739, 7, 20, 0, 0, 6739, 6740, 7, 4, 0, 0, 6740, 6741, + 7, 10, 0, 0, 6741, 6742, 7, 0, 0, 0, 6742, 6743, 7, 20, 0, 0, 6743, 690, + 1, 0, 0, 0, 6744, 6745, 7, 21, 0, 0, 6745, 6746, 7, 4, 0, 0, 6746, 6747, + 7, 4, 0, 0, 6747, 6748, 7, 21, 0, 0, 6748, 6749, 7, 20, 0, 0, 6749, 6750, + 7, 9, 0, 0, 6750, 6751, 5, 95, 0, 0, 6751, 6752, 7, 0, 0, 0, 6752, 6753, + 7, 17, 0, 0, 6753, 6754, 7, 1, 0, 0, 6754, 6755, 7, 6, 0, 0, 6755, 6756, + 7, 9, 0, 0, 6756, 6757, 7, 8, 0, 0, 6757, 6758, 7, 14, 0, 0, 6758, 6759, + 7, 9, 0, 0, 6759, 692, 1, 0, 0, 0, 6760, 6761, 7, 21, 0, 0, 6761, 6762, + 7, 4, 0, 0, 6762, 6763, 7, 11, 0, 0, 6763, 6764, 7, 4, 0, 0, 6764, 694, + 1, 0, 0, 0, 6765, 6766, 7, 21, 0, 0, 6766, 6767, 7, 3, 0, 0, 6767, 6768, + 7, 0, 0, 0, 6768, 6769, 7, 8, 0, 0, 6769, 6770, 7, 11, 0, 0, 6770, 696, + 1, 0, 0, 0, 6771, 6772, 7, 21, 0, 0, 6772, 6773, 7, 3, 0, 0, 6773, 6774, + 7, 0, 0, 0, 6774, 6775, 7, 8, 0, 0, 6775, 6776, 7, 11, 0, 0, 6776, 6777, + 7, 7, 0, 0, 6777, 698, 1, 0, 0, 0, 6778, 6779, 7, 21, 0, 0, 6779, 6780, + 7, 3, 0, 0, 6780, 6781, 7, 4, 0, 0, 6781, 6782, 7, 17, 0, 0, 6782, 6783, + 7, 2, 0, 0, 6783, 700, 1, 0, 0, 0, 6784, 6785, 7, 21, 0, 0, 6785, 6786, + 7, 3, 0, 0, 6786, 6787, 7, 4, 0, 0, 6787, 6788, 7, 17, 0, 0, 6788, 6789, + 7, 2, 0, 0, 6789, 6790, 7, 6, 0, 0, 6790, 6791, 7, 8, 0, 0, 6791, 6792, + 7, 21, 0, 0, 6792, 702, 1, 0, 0, 0, 6793, 6794, 7, 21, 0, 0, 6794, 6795, + 7, 3, 0, 0, 6795, 6796, 7, 4, 0, 0, 6796, 6797, 7, 17, 0, 0, 6797, 6798, + 7, 2, 0, 0, 6798, 6799, 7, 6, 0, 0, 6799, 6800, 7, 8, 0, 0, 6800, 6801, + 7, 21, 0, 0, 6801, 6802, 5, 95, 0, 0, 6802, 6803, 7, 6, 0, 0, 6803, 6804, + 7, 1, 0, 0, 6804, 704, 1, 0, 0, 0, 6805, 6806, 7, 21, 0, 0, 6806, 6807, + 7, 3, 0, 0, 6807, 6808, 7, 4, 0, 0, 6808, 6809, 7, 17, 0, 0, 6809, 6810, + 7, 2, 0, 0, 6810, 6811, 7, 7, 0, 0, 6811, 706, 1, 0, 0, 0, 6812, 6813, + 7, 21, 0, 0, 6813, 6814, 7, 24, 0, 0, 6814, 6815, 7, 6, 0, 0, 6815, 6816, + 7, 2, 0, 0, 6816, 708, 1, 0, 0, 0, 6817, 6818, 7, 15, 0, 0, 6818, 6819, + 7, 0, 0, 0, 6819, 6820, 7, 5, 0, 0, 6820, 6821, 7, 6, 0, 0, 6821, 6822, + 7, 8, 0, 0, 6822, 6823, 7, 21, 0, 0, 6823, 710, 1, 0, 0, 0, 6824, 6825, + 7, 15, 0, 0, 6825, 6826, 7, 9, 0, 0, 6826, 6827, 7, 0, 0, 0, 6827, 6828, + 7, 1, 0, 0, 6828, 6829, 7, 9, 0, 0, 6829, 6830, 7, 3, 0, 0, 6830, 712, + 1, 0, 0, 0, 6831, 6832, 7, 15, 0, 0, 6832, 6833, 7, 9, 0, 0, 6833, 6834, + 7, 0, 0, 0, 6834, 6835, 7, 1, 0, 0, 6835, 6836, 7, 9, 0, 0, 6836, 6837, + 7, 3, 0, 0, 6837, 6838, 7, 7, 0, 0, 6838, 714, 1, 0, 0, 0, 6839, 6840, + 7, 15, 0, 0, 6840, 6841, 7, 9, 0, 0, 6841, 6842, 7, 23, 0, 0, 6842, 716, + 1, 0, 0, 0, 6843, 6844, 7, 15, 0, 0, 6844, 6845, 7, 6, 0, 0, 6845, 6846, + 7, 9, 0, 0, 6846, 6847, 7, 3, 0, 0, 6847, 6848, 7, 0, 0, 0, 6848, 6849, + 7, 3, 0, 0, 6849, 6850, 7, 14, 0, 0, 6850, 6851, 7, 15, 0, 0, 6851, 6852, + 7, 18, 0, 0, 6852, 6853, 7, 6, 0, 0, 6853, 6854, 7, 1, 0, 0, 6854, 718, + 1, 0, 0, 0, 6855, 6856, 7, 15, 0, 0, 6856, 6857, 7, 6, 0, 0, 6857, 6858, + 7, 21, 0, 0, 6858, 6859, 7, 15, 0, 0, 6859, 720, 1, 0, 0, 0, 6860, 6861, + 7, 15, 0, 0, 6861, 6862, 7, 6, 0, 0, 6862, 6863, 7, 7, 0, 0, 6863, 6864, + 7, 11, 0, 0, 6864, 6865, 7, 4, 0, 0, 6865, 6866, 7, 3, 0, 0, 6866, 6867, + 7, 18, 0, 0, 6867, 722, 1, 0, 0, 0, 6868, 6869, 7, 15, 0, 0, 6869, 6870, + 7, 4, 0, 0, 6870, 6871, 7, 17, 0, 0, 6871, 6872, 7, 3, 0, 0, 6872, 6873, + 7, 7, 0, 0, 6873, 724, 1, 0, 0, 0, 6874, 6875, 7, 6, 0, 0, 6875, 6876, + 7, 1, 0, 0, 6876, 6877, 7, 9, 0, 0, 6877, 6878, 7, 8, 0, 0, 6878, 6879, + 7, 11, 0, 0, 6879, 6880, 7, 6, 0, 0, 6880, 6881, 7, 11, 0, 0, 6881, 6882, + 7, 18, 0, 0, 6882, 726, 1, 0, 0, 0, 6883, 6884, 7, 6, 0, 0, 6884, 6885, + 7, 12, 0, 0, 6885, 728, 1, 0, 0, 0, 6886, 6887, 7, 6, 0, 0, 6887, 6888, + 7, 12, 0, 0, 6888, 6889, 7, 12, 0, 0, 6889, 730, 1, 0, 0, 0, 6890, 6891, + 7, 6, 0, 0, 6891, 6892, 7, 12, 0, 0, 6892, 6893, 7, 8, 0, 0, 6893, 6894, + 7, 17, 0, 0, 6894, 6895, 7, 20, 0, 0, 6895, 6896, 7, 20, 0, 0, 6896, 732, + 1, 0, 0, 0, 6897, 6898, 7, 6, 0, 0, 6898, 6899, 7, 21, 0, 0, 6899, 6900, + 7, 8, 0, 0, 6900, 6901, 7, 4, 0, 0, 6901, 6902, 7, 3, 0, 0, 6902, 6903, + 7, 9, 0, 0, 6903, 734, 1, 0, 0, 0, 6904, 6905, 7, 6, 0, 0, 6905, 6906, + 7, 21, 0, 0, 6906, 6907, 7, 8, 0, 0, 6907, 6908, 7, 4, 0, 0, 6908, 6909, + 7, 3, 0, 0, 6909, 6910, 7, 9, 0, 0, 6910, 6911, 5, 95, 0, 0, 6911, 6912, + 7, 14, 0, 0, 6912, 6913, 7, 4, 0, 0, 6913, 6914, 7, 8, 0, 0, 6914, 6915, + 7, 7, 0, 0, 6915, 6916, 7, 11, 0, 0, 6916, 6917, 7, 3, 0, 0, 6917, 6918, + 7, 0, 0, 0, 6918, 6919, 7, 6, 0, 0, 6919, 6920, 7, 8, 0, 0, 6920, 6921, + 7, 11, 0, 0, 6921, 6922, 7, 7, 0, 0, 6922, 736, 1, 0, 0, 0, 6923, 6924, + 7, 6, 0, 0, 6924, 6925, 7, 21, 0, 0, 6925, 6926, 7, 8, 0, 0, 6926, 6927, + 7, 4, 0, 0, 6927, 6928, 7, 3, 0, 0, 6928, 6929, 7, 9, 0, 0, 6929, 6930, + 5, 95, 0, 0, 6930, 6931, 7, 1, 0, 0, 6931, 6932, 7, 17, 0, 0, 6932, 6933, + 7, 2, 0, 0, 6933, 6934, 5, 95, 0, 0, 6934, 6935, 7, 22, 0, 0, 6935, 6936, + 7, 9, 0, 0, 6936, 6937, 7, 18, 0, 0, 6937, 738, 1, 0, 0, 0, 6938, 6939, + 7, 6, 0, 0, 6939, 6940, 7, 21, 0, 0, 6940, 6941, 7, 8, 0, 0, 6941, 6942, + 7, 4, 0, 0, 6942, 6943, 7, 3, 0, 0, 6943, 6944, 7, 9, 0, 0, 6944, 6945, + 5, 95, 0, 0, 6945, 6946, 7, 8, 0, 0, 6946, 6947, 7, 4, 0, 0, 6947, 6948, + 7, 8, 0, 0, 6948, 6949, 7, 14, 0, 0, 6949, 6950, 7, 20, 0, 0, 6950, 6951, + 7, 17, 0, 0, 6951, 6952, 7, 7, 0, 0, 6952, 6953, 7, 11, 0, 0, 6953, 6954, + 7, 9, 0, 0, 6954, 6955, 7, 3, 0, 0, 6955, 6956, 7, 9, 0, 0, 6956, 6957, + 7, 1, 0, 0, 6957, 6958, 5, 95, 0, 0, 6958, 6959, 7, 14, 0, 0, 6959, 6960, + 7, 4, 0, 0, 6960, 6961, 7, 20, 0, 0, 6961, 6962, 7, 17, 0, 0, 6962, 6963, + 7, 19, 0, 0, 6963, 6964, 7, 8, 0, 0, 6964, 6965, 7, 7, 0, 0, 6965, 6966, + 7, 11, 0, 0, 6966, 6967, 7, 4, 0, 0, 6967, 6968, 7, 3, 0, 0, 6968, 6969, + 7, 9, 0, 0, 6969, 6970, 5, 95, 0, 0, 6970, 6971, 7, 6, 0, 0, 6971, 6972, + 7, 8, 0, 0, 6972, 6973, 7, 1, 0, 0, 6973, 6974, 7, 9, 0, 0, 6974, 6975, + 7, 23, 0, 0, 6975, 740, 1, 0, 0, 0, 6976, 6977, 7, 6, 0, 0, 6977, 6978, + 7, 21, 0, 0, 6978, 6979, 7, 8, 0, 0, 6979, 6980, 7, 4, 0, 0, 6980, 6981, + 7, 3, 0, 0, 6981, 6982, 7, 9, 0, 0, 6982, 6983, 5, 95, 0, 0, 6983, 6984, + 7, 11, 0, 0, 6984, 6985, 7, 3, 0, 0, 6985, 6986, 7, 6, 0, 0, 6986, 6987, + 7, 21, 0, 0, 6987, 6988, 7, 21, 0, 0, 6988, 6989, 7, 9, 0, 0, 6989, 6990, + 7, 3, 0, 0, 6990, 6991, 7, 7, 0, 0, 6991, 742, 1, 0, 0, 0, 6992, 6993, + 7, 6, 0, 0, 6993, 6994, 7, 21, 0, 0, 6994, 6995, 7, 8, 0, 0, 6995, 6996, + 7, 4, 0, 0, 6996, 6997, 7, 3, 0, 0, 6997, 6998, 7, 9, 0, 0, 6998, 6999, + 5, 95, 0, 0, 6999, 7000, 7, 17, 0, 0, 7000, 7001, 7, 11, 0, 0, 7001, 7002, + 7, 12, 0, 0, 7002, 7003, 5, 56, 0, 0, 7003, 7004, 5, 95, 0, 0, 7004, 7005, + 7, 9, 0, 0, 7005, 7006, 7, 3, 0, 0, 7006, 7007, 7, 3, 0, 0, 7007, 7008, + 7, 4, 0, 0, 7008, 7009, 7, 3, 0, 0, 7009, 7010, 7, 7, 0, 0, 7010, 744, + 1, 0, 0, 0, 7011, 7012, 7, 6, 0, 0, 7012, 7013, 7, 20, 0, 0, 7013, 7014, + 7, 6, 0, 0, 7014, 7015, 7, 22, 0, 0, 7015, 7016, 7, 9, 0, 0, 7016, 746, + 1, 0, 0, 0, 7017, 7018, 7, 6, 0, 0, 7018, 7019, 7, 19, 0, 0, 7019, 7020, + 7, 19, 0, 0, 7020, 7021, 7, 9, 0, 0, 7021, 7022, 7, 1, 0, 0, 7022, 7023, + 7, 6, 0, 0, 7023, 7024, 7, 0, 0, 0, 7024, 7025, 7, 11, 0, 0, 7025, 7026, + 7, 9, 0, 0, 7026, 748, 1, 0, 0, 0, 7027, 7028, 7, 6, 0, 0, 7028, 7029, + 7, 19, 0, 0, 7029, 7030, 7, 19, 0, 0, 7030, 7031, 7, 9, 0, 0, 7031, 7032, + 7, 1, 0, 0, 7032, 7033, 7, 6, 0, 0, 7033, 7034, 7, 0, 0, 0, 7034, 7035, + 7, 11, 0, 0, 7035, 7036, 7, 9, 0, 0, 7036, 7037, 7, 20, 0, 0, 7037, 7038, + 7, 18, 0, 0, 7038, 750, 1, 0, 0, 0, 7039, 7040, 7, 6, 0, 0, 7040, 7041, + 7, 19, 0, 0, 7041, 7042, 7, 19, 0, 0, 7042, 7043, 7, 17, 0, 0, 7043, 7044, + 7, 11, 0, 0, 7044, 7045, 7, 0, 0, 0, 7045, 7046, 7, 10, 0, 0, 7046, 7047, + 7, 20, 0, 0, 7047, 7048, 7, 9, 0, 0, 7048, 752, 1, 0, 0, 0, 7049, 7050, + 7, 6, 0, 0, 7050, 7051, 7, 19, 0, 0, 7051, 7052, 7, 2, 0, 0, 7052, 7053, + 7, 20, 0, 0, 7053, 7054, 7, 6, 0, 0, 7054, 7055, 7, 14, 0, 0, 7055, 7056, + 7, 6, 0, 0, 7056, 7057, 7, 11, 0, 0, 7057, 754, 1, 0, 0, 0, 7058, 7059, + 7, 6, 0, 0, 7059, 7060, 7, 19, 0, 0, 7060, 7061, 7, 2, 0, 0, 7061, 7062, + 7, 4, 0, 0, 7062, 7063, 7, 3, 0, 0, 7063, 7064, 7, 11, 0, 0, 7064, 756, + 1, 0, 0, 0, 7065, 7066, 7, 6, 0, 0, 7066, 7067, 7, 19, 0, 0, 7067, 7068, + 7, 2, 0, 0, 7068, 7069, 7, 4, 0, 0, 7069, 7070, 7, 3, 0, 0, 7070, 7071, + 7, 11, 0, 0, 7071, 7072, 7, 9, 0, 0, 7072, 7073, 7, 1, 0, 0, 7073, 758, + 1, 0, 0, 0, 7074, 7075, 7, 6, 0, 0, 7075, 7076, 7, 8, 0, 0, 7076, 760, + 1, 0, 0, 0, 7077, 7078, 7, 6, 0, 0, 7078, 7079, 7, 8, 0, 0, 7079, 7080, + 7, 14, 0, 0, 7080, 7081, 7, 3, 0, 0, 7081, 7082, 7, 9, 0, 0, 7082, 7083, + 7, 19, 0, 0, 7083, 7084, 7, 9, 0, 0, 7084, 7085, 7, 8, 0, 0, 7085, 7086, + 7, 11, 0, 0, 7086, 762, 1, 0, 0, 0, 7087, 7088, 7, 6, 0, 0, 7088, 7089, + 7, 8, 0, 0, 7089, 7090, 7, 1, 0, 0, 7090, 7091, 7, 9, 0, 0, 7091, 7092, + 7, 23, 0, 0, 7092, 764, 1, 0, 0, 0, 7093, 7094, 7, 6, 0, 0, 7094, 7095, + 7, 8, 0, 0, 7095, 7096, 7, 12, 0, 0, 7096, 7097, 7, 4, 0, 0, 7097, 7098, + 7, 3, 0, 0, 7098, 7099, 7, 19, 0, 0, 7099, 7100, 7, 0, 0, 0, 7100, 7101, + 7, 11, 0, 0, 7101, 7102, 7, 6, 0, 0, 7102, 7103, 7, 4, 0, 0, 7103, 7104, + 7, 8, 0, 0, 7104, 766, 1, 0, 0, 0, 7105, 7106, 7, 6, 0, 0, 7106, 7107, + 7, 8, 0, 0, 7107, 7108, 7, 6, 0, 0, 7108, 7109, 7, 11, 0, 0, 7109, 768, + 1, 0, 0, 0, 7110, 7111, 7, 6, 0, 0, 7111, 7112, 7, 8, 0, 0, 7112, 7113, + 7, 6, 0, 0, 7113, 7114, 7, 11, 0, 0, 7114, 7115, 7, 6, 0, 0, 7115, 7116, + 7, 0, 0, 0, 7116, 7117, 7, 20, 0, 0, 7117, 7118, 7, 20, 0, 0, 7118, 7119, + 7, 18, 0, 0, 7119, 770, 1, 0, 0, 0, 7120, 7121, 7, 6, 0, 0, 7121, 7122, + 7, 8, 0, 0, 7122, 7123, 7, 6, 0, 0, 7123, 7124, 7, 11, 0, 0, 7124, 7125, + 7, 6, 0, 0, 7125, 7126, 7, 0, 0, 0, 7126, 7127, 7, 20, 0, 0, 7127, 7128, + 7, 20, 0, 0, 7128, 7129, 7, 18, 0, 0, 7129, 7130, 5, 95, 0, 0, 7130, 7131, + 7, 7, 0, 0, 7131, 7132, 7, 17, 0, 0, 7132, 7133, 7, 7, 0, 0, 7133, 7134, + 7, 2, 0, 0, 7134, 7135, 7, 9, 0, 0, 7135, 7136, 7, 8, 0, 0, 7136, 7137, + 7, 1, 0, 0, 7137, 7138, 7, 9, 0, 0, 7138, 7139, 7, 1, 0, 0, 7139, 772, + 1, 0, 0, 0, 7140, 7141, 7, 6, 0, 0, 7141, 7142, 7, 8, 0, 0, 7142, 7143, + 7, 6, 0, 0, 7143, 7144, 7, 11, 0, 0, 7144, 7145, 7, 6, 0, 0, 7145, 7146, + 7, 0, 0, 0, 7146, 7147, 7, 20, 0, 0, 7147, 7148, 5, 95, 0, 0, 7148, 7149, + 7, 3, 0, 0, 7149, 7150, 7, 9, 0, 0, 7150, 7151, 7, 2, 0, 0, 7151, 7152, + 7, 20, 0, 0, 7152, 7153, 7, 6, 0, 0, 7153, 7154, 7, 14, 0, 0, 7154, 7155, + 7, 0, 0, 0, 7155, 7156, 7, 11, 0, 0, 7156, 7157, 7, 6, 0, 0, 7157, 7158, + 7, 4, 0, 0, 7158, 7159, 7, 8, 0, 0, 7159, 7160, 5, 95, 0, 0, 7160, 7161, + 7, 7, 0, 0, 7161, 7162, 7, 6, 0, 0, 7162, 7163, 7, 24, 0, 0, 7163, 7164, + 7, 9, 0, 0, 7164, 7165, 5, 95, 0, 0, 7165, 7166, 7, 20, 0, 0, 7166, 7167, + 7, 6, 0, 0, 7167, 7168, 7, 19, 0, 0, 7168, 7169, 7, 6, 0, 0, 7169, 7170, + 7, 11, 0, 0, 7170, 7171, 5, 95, 0, 0, 7171, 7172, 7, 6, 0, 0, 7172, 7173, + 7, 8, 0, 0, 7173, 7174, 5, 95, 0, 0, 7174, 7175, 7, 11, 0, 0, 7175, 7176, + 7, 10, 0, 0, 7176, 774, 1, 0, 0, 0, 7177, 7178, 7, 6, 0, 0, 7178, 7179, + 7, 8, 0, 0, 7179, 7180, 7, 8, 0, 0, 7180, 7181, 7, 9, 0, 0, 7181, 7182, + 7, 3, 0, 0, 7182, 776, 1, 0, 0, 0, 7183, 7184, 7, 6, 0, 0, 7184, 7185, + 7, 8, 0, 0, 7185, 7186, 7, 2, 0, 0, 7186, 7187, 7, 17, 0, 0, 7187, 7188, + 7, 11, 0, 0, 7188, 778, 1, 0, 0, 0, 7189, 7190, 7, 6, 0, 0, 7190, 7191, + 7, 8, 0, 0, 7191, 7192, 7, 7, 0, 0, 7192, 7193, 7, 9, 0, 0, 7193, 7194, + 7, 3, 0, 0, 7194, 7195, 7, 11, 0, 0, 7195, 780, 1, 0, 0, 0, 7196, 7197, + 7, 6, 0, 0, 7197, 7198, 7, 8, 0, 0, 7198, 7199, 7, 7, 0, 0, 7199, 7200, + 7, 9, 0, 0, 7200, 7201, 7, 3, 0, 0, 7201, 7202, 7, 11, 0, 0, 7202, 7203, + 5, 95, 0, 0, 7203, 7204, 7, 4, 0, 0, 7204, 7205, 7, 8, 0, 0, 7205, 7206, + 7, 20, 0, 0, 7206, 7207, 7, 18, 0, 0, 7207, 782, 1, 0, 0, 0, 7208, 7209, + 7, 6, 0, 0, 7209, 7210, 7, 8, 0, 0, 7210, 7211, 7, 7, 0, 0, 7211, 7212, + 7, 11, 0, 0, 7212, 7213, 7, 9, 0, 0, 7213, 7214, 7, 0, 0, 0, 7214, 7215, + 7, 1, 0, 0, 7215, 784, 1, 0, 0, 0, 7216, 7217, 7, 6, 0, 0, 7217, 7218, + 7, 8, 0, 0, 7218, 7219, 7, 11, 0, 0, 7219, 786, 1, 0, 0, 0, 7220, 7221, + 7, 6, 0, 0, 7221, 7222, 7, 8, 0, 0, 7222, 7223, 7, 11, 0, 0, 7223, 7224, + 7, 9, 0, 0, 7224, 7225, 7, 21, 0, 0, 7225, 7226, 7, 3, 0, 0, 7226, 7227, + 7, 0, 0, 0, 7227, 7228, 7, 11, 0, 0, 7228, 7229, 7, 6, 0, 0, 7229, 7230, + 7, 4, 0, 0, 7230, 7231, 7, 8, 0, 0, 7231, 788, 1, 0, 0, 0, 7232, 7233, + 7, 6, 0, 0, 7233, 7234, 7, 8, 0, 0, 7234, 7235, 7, 11, 0, 0, 7235, 7236, + 7, 9, 0, 0, 7236, 7237, 7, 21, 0, 0, 7237, 7238, 7, 3, 0, 0, 7238, 7239, + 7, 0, 0, 0, 7239, 7240, 7, 11, 0, 0, 7240, 7241, 7, 6, 0, 0, 7241, 7242, + 7, 4, 0, 0, 7242, 7243, 7, 8, 0, 0, 7243, 7244, 7, 7, 0, 0, 7244, 790, + 1, 0, 0, 0, 7245, 7246, 7, 6, 0, 0, 7246, 7247, 7, 8, 0, 0, 7247, 7248, + 7, 11, 0, 0, 7248, 7249, 7, 9, 0, 0, 7249, 7250, 7, 3, 0, 0, 7250, 7251, + 7, 7, 0, 0, 7251, 7252, 7, 9, 0, 0, 7252, 7253, 7, 14, 0, 0, 7253, 7254, + 7, 11, 0, 0, 7254, 792, 1, 0, 0, 0, 7255, 7256, 7, 6, 0, 0, 7256, 7257, + 7, 8, 0, 0, 7257, 7258, 7, 11, 0, 0, 7258, 7259, 7, 4, 0, 0, 7259, 794, + 1, 0, 0, 0, 7260, 7261, 7, 6, 0, 0, 7261, 7262, 7, 7, 0, 0, 7262, 796, + 1, 0, 0, 0, 7263, 7264, 7, 6, 0, 0, 7264, 7265, 7, 7, 0, 0, 7265, 7266, + 7, 8, 0, 0, 7266, 7267, 7, 17, 0, 0, 7267, 7268, 7, 20, 0, 0, 7268, 7269, + 7, 20, 0, 0, 7269, 798, 1, 0, 0, 0, 7270, 7271, 7, 6, 0, 0, 7271, 7272, + 7, 7, 0, 0, 7272, 7273, 7, 8, 0, 0, 7273, 7274, 7, 17, 0, 0, 7274, 7275, + 7, 19, 0, 0, 7275, 7276, 7, 9, 0, 0, 7276, 7277, 7, 3, 0, 0, 7277, 7278, + 7, 6, 0, 0, 7278, 7279, 7, 14, 0, 0, 7279, 800, 1, 0, 0, 0, 7280, 7281, + 7, 6, 0, 0, 7281, 7282, 7, 7, 0, 0, 7282, 7283, 7, 4, 0, 0, 7283, 7284, + 7, 20, 0, 0, 7284, 7285, 7, 0, 0, 0, 7285, 7286, 7, 11, 0, 0, 7286, 7287, + 7, 6, 0, 0, 7287, 7288, 7, 4, 0, 0, 7288, 7289, 7, 8, 0, 0, 7289, 802, + 1, 0, 0, 0, 7290, 7291, 7, 25, 0, 0, 7291, 7292, 7, 0, 0, 0, 7292, 7293, + 7, 5, 0, 0, 7293, 7294, 7, 0, 0, 0, 7294, 7295, 7, 7, 0, 0, 7295, 7296, + 7, 14, 0, 0, 7296, 7297, 7, 3, 0, 0, 7297, 7298, 7, 6, 0, 0, 7298, 7299, + 7, 2, 0, 0, 7299, 7300, 7, 11, 0, 0, 7300, 804, 1, 0, 0, 0, 7301, 7302, + 7, 25, 0, 0, 7302, 7303, 7, 1, 0, 0, 7303, 7304, 7, 10, 0, 0, 7304, 7305, + 7, 14, 0, 0, 7305, 7306, 5, 95, 0, 0, 7306, 7307, 7, 11, 0, 0, 7307, 7308, + 7, 3, 0, 0, 7308, 7309, 7, 9, 0, 0, 7309, 7310, 7, 0, 0, 0, 7310, 7311, + 7, 11, 0, 0, 7311, 7312, 5, 95, 0, 0, 7312, 7313, 7, 1, 0, 0, 7313, 7314, + 7, 9, 0, 0, 7314, 7315, 7, 14, 0, 0, 7315, 7316, 7, 6, 0, 0, 7316, 7317, + 7, 19, 0, 0, 7317, 7318, 7, 0, 0, 0, 7318, 7319, 7, 20, 0, 0, 7319, 7320, + 5, 95, 0, 0, 7320, 7321, 7, 0, 0, 0, 7321, 7322, 7, 7, 0, 0, 7322, 7323, + 5, 95, 0, 0, 7323, 7324, 7, 6, 0, 0, 7324, 7325, 7, 8, 0, 0, 7325, 7326, + 7, 11, 0, 0, 7326, 806, 1, 0, 0, 0, 7327, 7328, 7, 25, 0, 0, 7328, 7329, + 7, 1, 0, 0, 7329, 7330, 7, 10, 0, 0, 7330, 7331, 7, 14, 0, 0, 7331, 7332, + 5, 95, 0, 0, 7332, 7333, 7, 11, 0, 0, 7333, 7334, 7, 3, 0, 0, 7334, 7335, + 7, 9, 0, 0, 7335, 7336, 7, 0, 0, 0, 7336, 7337, 7, 11, 0, 0, 7337, 7338, + 5, 95, 0, 0, 7338, 7339, 7, 11, 0, 0, 7339, 7340, 7, 6, 0, 0, 7340, 7341, + 7, 19, 0, 0, 7341, 7342, 7, 9, 0, 0, 7342, 7343, 7, 7, 0, 0, 7343, 7344, + 7, 11, 0, 0, 7344, 7345, 7, 0, 0, 0, 7345, 7346, 7, 19, 0, 0, 7346, 7347, + 7, 2, 0, 0, 7347, 7348, 5, 95, 0, 0, 7348, 7349, 7, 8, 0, 0, 7349, 7350, + 7, 11, 0, 0, 7350, 7351, 7, 24, 0, 0, 7351, 7352, 5, 95, 0, 0, 7352, 7353, + 7, 0, 0, 0, 7353, 7354, 7, 7, 0, 0, 7354, 7355, 5, 95, 0, 0, 7355, 7356, + 7, 17, 0, 0, 7356, 7357, 7, 11, 0, 0, 7357, 7358, 7, 14, 0, 0, 7358, 808, + 1, 0, 0, 0, 7359, 7360, 7, 25, 0, 0, 7360, 7361, 7, 1, 0, 0, 7361, 7362, + 7, 10, 0, 0, 7362, 7363, 7, 14, 0, 0, 7363, 7364, 5, 95, 0, 0, 7364, 7365, + 7, 17, 0, 0, 7365, 7366, 7, 7, 0, 0, 7366, 7367, 7, 9, 0, 0, 7367, 7368, + 5, 95, 0, 0, 7368, 7369, 7, 7, 0, 0, 7369, 7370, 7, 9, 0, 0, 7370, 7371, + 7, 7, 0, 0, 7371, 7372, 7, 7, 0, 0, 7372, 7373, 7, 6, 0, 0, 7373, 7374, + 7, 4, 0, 0, 7374, 7375, 7, 8, 0, 0, 7375, 7376, 5, 95, 0, 0, 7376, 7377, + 7, 11, 0, 0, 7377, 7378, 7, 6, 0, 0, 7378, 7379, 7, 19, 0, 0, 7379, 7380, + 7, 9, 0, 0, 7380, 7381, 7, 24, 0, 0, 7381, 7382, 7, 4, 0, 0, 7382, 7383, + 7, 8, 0, 0, 7383, 7384, 7, 9, 0, 0, 7384, 810, 1, 0, 0, 0, 7385, 7386, + 7, 25, 0, 0, 7386, 7387, 7, 4, 0, 0, 7387, 7388, 7, 6, 0, 0, 7388, 7389, + 7, 8, 0, 0, 7389, 812, 1, 0, 0, 0, 7390, 7391, 7, 25, 0, 0, 7391, 7392, + 7, 7, 0, 0, 7392, 7393, 7, 4, 0, 0, 7393, 7394, 7, 8, 0, 0, 7394, 814, + 1, 0, 0, 0, 7395, 7396, 5, 39, 0, 0, 7396, 7397, 7, 25, 0, 0, 7397, 7398, + 7, 7, 0, 0, 7398, 7399, 7, 4, 0, 0, 7399, 7400, 7, 8, 0, 0, 7400, 7401, + 5, 39, 0, 0, 7401, 816, 1, 0, 0, 0, 7402, 7403, 7, 25, 0, 0, 7403, 7404, + 7, 7, 0, 0, 7404, 7405, 7, 4, 0, 0, 7405, 7406, 7, 8, 0, 0, 7406, 7407, + 5, 95, 0, 0, 7407, 7408, 7, 6, 0, 0, 7408, 7409, 7, 8, 0, 0, 7409, 7410, + 7, 1, 0, 0, 7410, 7411, 7, 9, 0, 0, 7411, 7412, 7, 8, 0, 0, 7412, 7413, + 7, 11, 0, 0, 7413, 818, 1, 0, 0, 0, 7414, 7415, 7, 25, 0, 0, 7415, 7416, + 7, 7, 0, 0, 7416, 7417, 5, 95, 0, 0, 7417, 7418, 7, 11, 0, 0, 7418, 7419, + 7, 3, 0, 0, 7419, 7420, 7, 9, 0, 0, 7420, 7421, 7, 0, 0, 0, 7421, 7422, + 7, 11, 0, 0, 7422, 7423, 5, 95, 0, 0, 7423, 7424, 7, 6, 0, 0, 7424, 7425, + 7, 8, 0, 0, 7425, 7426, 7, 11, 0, 0, 7426, 7427, 7, 9, 0, 0, 7427, 7428, + 7, 21, 0, 0, 7428, 7429, 7, 9, 0, 0, 7429, 7430, 7, 3, 0, 0, 7430, 7431, + 5, 95, 0, 0, 7431, 7432, 7, 0, 0, 0, 7432, 7433, 7, 7, 0, 0, 7433, 7434, + 5, 95, 0, 0, 7434, 7435, 7, 10, 0, 0, 7435, 7436, 7, 6, 0, 0, 7436, 7437, + 7, 21, 0, 0, 7437, 7438, 7, 6, 0, 0, 7438, 7439, 7, 8, 0, 0, 7439, 7440, + 7, 11, 0, 0, 7440, 820, 1, 0, 0, 0, 7441, 7442, 7, 22, 0, 0, 7442, 7443, + 7, 10, 0, 0, 7443, 822, 1, 0, 0, 0, 7444, 7445, 7, 22, 0, 0, 7445, 7446, + 7, 9, 0, 0, 7446, 7447, 7, 9, 0, 0, 7447, 7448, 7, 2, 0, 0, 7448, 824, + 1, 0, 0, 0, 7449, 7450, 7, 22, 0, 0, 7450, 7451, 7, 9, 0, 0, 7451, 7452, + 7, 18, 0, 0, 7452, 826, 1, 0, 0, 0, 7453, 7454, 7, 22, 0, 0, 7454, 7455, + 7, 9, 0, 0, 7455, 7456, 7, 18, 0, 0, 7456, 7457, 7, 7, 0, 0, 7457, 828, + 1, 0, 0, 0, 7458, 7459, 7, 22, 0, 0, 7459, 7460, 7, 9, 0, 0, 7460, 7461, + 7, 18, 0, 0, 7461, 7462, 7, 7, 0, 0, 7462, 7463, 7, 9, 0, 0, 7463, 7464, + 7, 11, 0, 0, 7464, 830, 1, 0, 0, 0, 7465, 7466, 7, 22, 0, 0, 7466, 7467, + 7, 19, 0, 0, 7467, 7468, 7, 7, 0, 0, 7468, 7469, 5, 95, 0, 0, 7469, 7470, + 7, 22, 0, 0, 7470, 7471, 7, 9, 0, 0, 7471, 7472, 7, 18, 0, 0, 7472, 7473, + 5, 95, 0, 0, 7473, 7474, 7, 6, 0, 0, 7474, 7475, 7, 1, 0, 0, 7475, 832, + 1, 0, 0, 0, 7476, 7477, 7, 20, 0, 0, 7477, 7478, 7, 0, 0, 0, 7478, 7479, + 7, 21, 0, 0, 7479, 834, 1, 0, 0, 0, 7480, 7481, 7, 20, 0, 0, 7481, 7482, + 7, 0, 0, 0, 7482, 7483, 7, 8, 0, 0, 7483, 7484, 7, 21, 0, 0, 7484, 7485, + 7, 17, 0, 0, 7485, 7486, 7, 0, 0, 0, 7486, 7487, 7, 21, 0, 0, 7487, 7488, + 7, 9, 0, 0, 7488, 836, 1, 0, 0, 0, 7489, 7490, 7, 20, 0, 0, 7490, 7491, + 7, 0, 0, 0, 7491, 7492, 7, 3, 0, 0, 7492, 7493, 7, 21, 0, 0, 7493, 7494, + 7, 9, 0, 0, 7494, 838, 1, 0, 0, 0, 7495, 7496, 7, 20, 0, 0, 7496, 7497, + 7, 0, 0, 0, 7497, 7498, 7, 7, 0, 0, 7498, 7499, 7, 11, 0, 0, 7499, 840, + 1, 0, 0, 0, 7500, 7501, 7, 20, 0, 0, 7501, 7502, 7, 0, 0, 0, 7502, 7503, + 7, 7, 0, 0, 7503, 7504, 7, 11, 0, 0, 7504, 7505, 5, 95, 0, 0, 7505, 7506, + 7, 8, 0, 0, 7506, 7507, 7, 0, 0, 0, 7507, 7508, 7, 19, 0, 0, 7508, 7509, + 7, 9, 0, 0, 7509, 842, 1, 0, 0, 0, 7510, 7511, 7, 20, 0, 0, 7511, 7512, + 7, 0, 0, 0, 7512, 7513, 7, 7, 0, 0, 7513, 7514, 7, 11, 0, 0, 7514, 7515, + 5, 95, 0, 0, 7515, 7516, 7, 16, 0, 0, 7516, 7517, 7, 17, 0, 0, 7517, 7518, + 7, 9, 0, 0, 7518, 7519, 7, 3, 0, 0, 7519, 7520, 7, 18, 0, 0, 7520, 7521, + 5, 95, 0, 0, 7521, 7522, 7, 6, 0, 0, 7522, 7523, 7, 1, 0, 0, 7523, 844, + 1, 0, 0, 0, 7524, 7525, 7, 20, 0, 0, 7525, 7526, 7, 0, 0, 0, 7526, 7527, + 7, 7, 0, 0, 7527, 7528, 7, 11, 0, 0, 7528, 7529, 5, 95, 0, 0, 7529, 7530, + 7, 5, 0, 0, 7530, 7531, 7, 0, 0, 0, 7531, 7532, 7, 20, 0, 0, 7532, 7533, + 7, 17, 0, 0, 7533, 7534, 7, 9, 0, 0, 7534, 846, 1, 0, 0, 0, 7535, 7536, + 7, 20, 0, 0, 7536, 7537, 7, 0, 0, 0, 7537, 7538, 7, 11, 0, 0, 7538, 7539, + 7, 9, 0, 0, 7539, 7540, 7, 3, 0, 0, 7540, 7541, 7, 0, 0, 0, 7541, 7542, + 7, 20, 0, 0, 7542, 848, 1, 0, 0, 0, 7543, 7544, 7, 20, 0, 0, 7544, 7545, + 7, 9, 0, 0, 7545, 7546, 7, 0, 0, 0, 7546, 7547, 7, 1, 0, 0, 7547, 850, + 1, 0, 0, 0, 7548, 7549, 7, 20, 0, 0, 7549, 7550, 7, 9, 0, 0, 7550, 7551, + 7, 12, 0, 0, 7551, 7552, 7, 11, 0, 0, 7552, 852, 1, 0, 0, 0, 7553, 7554, + 7, 20, 0, 0, 7554, 7555, 7, 9, 0, 0, 7555, 7556, 7, 8, 0, 0, 7556, 854, + 1, 0, 0, 0, 7557, 7558, 7, 20, 0, 0, 7558, 7559, 7, 9, 0, 0, 7559, 7560, + 7, 8, 0, 0, 7560, 7561, 7, 21, 0, 0, 7561, 7562, 7, 11, 0, 0, 7562, 7563, + 7, 15, 0, 0, 7563, 856, 1, 0, 0, 0, 7564, 7565, 7, 20, 0, 0, 7565, 7566, + 7, 9, 0, 0, 7566, 7567, 7, 5, 0, 0, 7567, 7568, 7, 9, 0, 0, 7568, 7569, + 7, 20, 0, 0, 7569, 858, 1, 0, 0, 0, 7570, 7571, 7, 20, 0, 0, 7571, 7572, + 7, 6, 0, 0, 7572, 7573, 7, 22, 0, 0, 7573, 7574, 7, 9, 0, 0, 7574, 860, + 1, 0, 0, 0, 7575, 7576, 7, 20, 0, 0, 7576, 7577, 7, 6, 0, 0, 7577, 7578, + 7, 19, 0, 0, 7578, 7579, 7, 6, 0, 0, 7579, 7580, 7, 11, 0, 0, 7580, 862, + 1, 0, 0, 0, 7581, 7582, 7, 20, 0, 0, 7582, 7583, 7, 6, 0, 0, 7583, 7584, + 7, 8, 0, 0, 7584, 7585, 7, 9, 0, 0, 7585, 7586, 7, 8, 0, 0, 7586, 7587, + 7, 4, 0, 0, 7587, 864, 1, 0, 0, 0, 7588, 7589, 7, 20, 0, 0, 7589, 7590, + 7, 6, 0, 0, 7590, 7591, 7, 7, 0, 0, 7591, 7592, 7, 11, 0, 0, 7592, 866, + 1, 0, 0, 0, 7593, 7594, 7, 20, 0, 0, 7594, 7595, 7, 6, 0, 0, 7595, 7596, + 7, 7, 0, 0, 7596, 7597, 7, 11, 0, 0, 7597, 7598, 7, 9, 0, 0, 7598, 7599, + 7, 8, 0, 0, 7599, 7600, 7, 9, 0, 0, 7600, 7601, 7, 3, 0, 0, 7601, 7602, + 5, 95, 0, 0, 7602, 7603, 7, 6, 0, 0, 7603, 7604, 7, 2, 0, 0, 7604, 868, + 1, 0, 0, 0, 7605, 7606, 7, 20, 0, 0, 7606, 7607, 7, 6, 0, 0, 7607, 7608, + 7, 7, 0, 0, 7608, 7609, 7, 11, 0, 0, 7609, 7610, 7, 9, 0, 0, 7610, 7611, + 7, 8, 0, 0, 7611, 7612, 7, 9, 0, 0, 7612, 7613, 7, 3, 0, 0, 7613, 7614, + 5, 95, 0, 0, 7614, 7615, 7, 2, 0, 0, 7615, 7616, 7, 4, 0, 0, 7616, 7617, + 7, 3, 0, 0, 7617, 7618, 7, 11, 0, 0, 7618, 870, 1, 0, 0, 0, 7619, 7620, + 7, 20, 0, 0, 7620, 7621, 7, 6, 0, 0, 7621, 7622, 7, 7, 0, 0, 7622, 7623, + 7, 11, 0, 0, 7623, 7624, 7, 6, 0, 0, 7624, 7625, 7, 8, 0, 0, 7625, 7626, + 7, 21, 0, 0, 7626, 872, 1, 0, 0, 0, 7627, 7628, 7, 20, 0, 0, 7628, 7629, + 7, 4, 0, 0, 7629, 7630, 7, 0, 0, 0, 7630, 7631, 7, 1, 0, 0, 7631, 874, + 1, 0, 0, 0, 7632, 7633, 7, 20, 0, 0, 7633, 7634, 7, 4, 0, 0, 7634, 7635, + 7, 14, 0, 0, 7635, 7636, 7, 0, 0, 0, 7636, 7637, 7, 20, 0, 0, 7637, 876, + 1, 0, 0, 0, 7638, 7639, 7, 20, 0, 0, 7639, 7640, 7, 4, 0, 0, 7640, 7641, + 7, 14, 0, 0, 7641, 7642, 7, 0, 0, 0, 7642, 7643, 7, 20, 0, 0, 7643, 7644, + 5, 95, 0, 0, 7644, 7645, 7, 7, 0, 0, 7645, 7646, 7, 9, 0, 0, 7646, 7647, + 7, 3, 0, 0, 7647, 7648, 7, 5, 0, 0, 7648, 7649, 7, 6, 0, 0, 7649, 7650, + 7, 14, 0, 0, 7650, 7651, 7, 9, 0, 0, 7651, 7652, 5, 95, 0, 0, 7652, 7653, + 7, 8, 0, 0, 7653, 7654, 7, 0, 0, 0, 7654, 7655, 7, 19, 0, 0, 7655, 7656, + 7, 9, 0, 0, 7656, 878, 1, 0, 0, 0, 7657, 7658, 7, 20, 0, 0, 7658, 7659, + 7, 4, 0, 0, 7659, 7660, 7, 14, 0, 0, 7660, 7661, 7, 0, 0, 0, 7661, 7662, + 7, 11, 0, 0, 7662, 7663, 7, 6, 0, 0, 7663, 7664, 7, 4, 0, 0, 7664, 7665, + 7, 8, 0, 0, 7665, 880, 1, 0, 0, 0, 7666, 7667, 7, 20, 0, 0, 7667, 7668, + 7, 4, 0, 0, 7668, 7669, 7, 14, 0, 0, 7669, 7670, 7, 22, 0, 0, 7670, 7671, + 7, 7, 0, 0, 7671, 882, 1, 0, 0, 0, 7672, 7673, 7, 20, 0, 0, 7673, 7674, + 7, 4, 0, 0, 7674, 7675, 7, 14, 0, 0, 7675, 7676, 7, 22, 0, 0, 7676, 7677, + 5, 95, 0, 0, 7677, 7678, 7, 11, 0, 0, 7678, 7679, 7, 6, 0, 0, 7679, 7680, + 7, 19, 0, 0, 7680, 7681, 7, 9, 0, 0, 7681, 7682, 7, 4, 0, 0, 7682, 7683, + 7, 17, 0, 0, 7683, 7684, 7, 11, 0, 0, 7684, 884, 1, 0, 0, 0, 7685, 7686, + 7, 20, 0, 0, 7686, 7687, 7, 4, 0, 0, 7687, 7688, 7, 21, 0, 0, 7688, 886, + 1, 0, 0, 0, 7689, 7690, 7, 20, 0, 0, 7690, 7691, 7, 4, 0, 0, 7691, 7692, + 7, 21, 0, 0, 7692, 7693, 7, 6, 0, 0, 7693, 7694, 7, 8, 0, 0, 7694, 888, + 1, 0, 0, 0, 7695, 7696, 7, 20, 0, 0, 7696, 7697, 7, 4, 0, 0, 7697, 7698, + 7, 21, 0, 0, 7698, 7699, 7, 6, 0, 0, 7699, 7700, 7, 8, 0, 0, 7700, 7701, + 5, 95, 0, 0, 7701, 7702, 7, 8, 0, 0, 7702, 7703, 7, 0, 0, 0, 7703, 7704, + 7, 19, 0, 0, 7704, 7705, 7, 9, 0, 0, 7705, 890, 1, 0, 0, 0, 7706, 7707, + 7, 20, 0, 0, 7707, 7708, 7, 4, 0, 0, 7708, 7709, 7, 4, 0, 0, 7709, 7710, + 7, 22, 0, 0, 7710, 7711, 7, 9, 0, 0, 7711, 7712, 7, 3, 0, 0, 7712, 892, + 1, 0, 0, 0, 7713, 7714, 7, 20, 0, 0, 7714, 7715, 7, 4, 0, 0, 7715, 7716, + 7, 13, 0, 0, 7716, 894, 1, 0, 0, 0, 7717, 7718, 7, 20, 0, 0, 7718, 7719, + 7, 4, 0, 0, 7719, 7720, 7, 13, 0, 0, 7720, 7721, 7, 9, 0, 0, 7721, 7722, + 7, 3, 0, 0, 7722, 896, 1, 0, 0, 0, 7723, 7724, 7, 20, 0, 0, 7724, 7725, + 7, 11, 0, 0, 7725, 7726, 7, 3, 0, 0, 7726, 7727, 7, 6, 0, 0, 7727, 7728, + 7, 19, 0, 0, 7728, 898, 1, 0, 0, 0, 7729, 7730, 7, 20, 0, 0, 7730, 7731, + 7, 24, 0, 0, 7731, 7732, 7, 4, 0, 0, 7732, 900, 1, 0, 0, 0, 7733, 7734, + 7, 19, 0, 0, 7734, 7735, 7, 0, 0, 0, 7735, 7736, 7, 8, 0, 0, 7736, 7737, + 7, 0, 0, 0, 7737, 7738, 7, 21, 0, 0, 7738, 7739, 7, 9, 0, 0, 7739, 902, + 1, 0, 0, 0, 7740, 7741, 7, 19, 0, 0, 7741, 7742, 7, 0, 0, 0, 7742, 7743, + 7, 8, 0, 0, 7743, 7744, 7, 0, 0, 0, 7744, 7745, 7, 21, 0, 0, 7745, 7746, + 7, 9, 0, 0, 7746, 7747, 7, 1, 0, 0, 7747, 904, 1, 0, 0, 0, 7748, 7749, + 7, 19, 0, 0, 7749, 7750, 7, 0, 0, 0, 7750, 7751, 7, 7, 0, 0, 7751, 7752, + 7, 22, 0, 0, 7752, 906, 1, 0, 0, 0, 7753, 7754, 7, 19, 0, 0, 7754, 7755, + 7, 0, 0, 0, 7755, 7756, 7, 7, 0, 0, 7756, 7757, 7, 22, 0, 0, 7757, 7758, + 7, 9, 0, 0, 7758, 7759, 7, 1, 0, 0, 7759, 908, 1, 0, 0, 0, 7760, 7761, + 7, 19, 0, 0, 7761, 7762, 7, 0, 0, 0, 7762, 7763, 7, 7, 0, 0, 7763, 7764, + 7, 22, 0, 0, 7764, 7765, 7, 6, 0, 0, 7765, 7766, 7, 8, 0, 0, 7766, 7767, + 7, 21, 0, 0, 7767, 910, 1, 0, 0, 0, 7768, 7769, 7, 19, 0, 0, 7769, 7770, + 7, 0, 0, 0, 7770, 7771, 7, 7, 0, 0, 7771, 7772, 7, 11, 0, 0, 7772, 7773, + 7, 9, 0, 0, 7773, 7774, 7, 3, 0, 0, 7774, 912, 1, 0, 0, 0, 7775, 7776, + 7, 19, 0, 0, 7776, 7777, 7, 0, 0, 0, 7777, 7778, 7, 7, 0, 0, 7778, 7779, + 7, 11, 0, 0, 7779, 7780, 7, 9, 0, 0, 7780, 7781, 7, 3, 0, 0, 7781, 7782, + 5, 95, 0, 0, 7782, 7783, 7, 22, 0, 0, 7783, 7784, 7, 9, 0, 0, 7784, 7785, + 7, 18, 0, 0, 7785, 914, 1, 0, 0, 0, 7786, 7787, 7, 19, 0, 0, 7787, 7788, + 7, 0, 0, 0, 7788, 7789, 7, 11, 0, 0, 7789, 7790, 7, 14, 0, 0, 7790, 7791, + 7, 15, 0, 0, 7791, 916, 1, 0, 0, 0, 7792, 7793, 7, 19, 0, 0, 7793, 7794, + 7, 0, 0, 0, 7794, 7795, 7, 11, 0, 0, 7795, 7796, 7, 14, 0, 0, 7796, 7797, + 7, 15, 0, 0, 7797, 7798, 7, 9, 0, 0, 7798, 7799, 7, 1, 0, 0, 7799, 918, + 1, 0, 0, 0, 7800, 7801, 7, 19, 0, 0, 7801, 7802, 7, 0, 0, 0, 7802, 7803, + 7, 11, 0, 0, 7803, 7804, 7, 14, 0, 0, 7804, 7805, 7, 15, 0, 0, 7805, 7806, + 7, 9, 0, 0, 7806, 7807, 7, 7, 0, 0, 7807, 920, 1, 0, 0, 0, 7808, 7809, + 7, 19, 0, 0, 7809, 7810, 7, 0, 0, 0, 7810, 7811, 7, 11, 0, 0, 7811, 7812, + 7, 14, 0, 0, 7812, 7813, 7, 15, 0, 0, 7813, 7814, 5, 95, 0, 0, 7814, 7815, + 7, 10, 0, 0, 7815, 7816, 7, 18, 0, 0, 7816, 7817, 5, 95, 0, 0, 7817, 7818, + 7, 14, 0, 0, 7818, 7819, 7, 4, 0, 0, 7819, 7820, 7, 20, 0, 0, 7820, 7821, + 7, 17, 0, 0, 7821, 7822, 7, 19, 0, 0, 7822, 7823, 7, 8, 0, 0, 7823, 7824, + 5, 95, 0, 0, 7824, 7825, 7, 8, 0, 0, 7825, 7826, 7, 0, 0, 0, 7826, 7827, + 7, 19, 0, 0, 7827, 7828, 7, 9, 0, 0, 7828, 922, 1, 0, 0, 0, 7829, 7830, + 7, 19, 0, 0, 7830, 7831, 7, 0, 0, 0, 7831, 7832, 7, 11, 0, 0, 7832, 7833, + 7, 14, 0, 0, 7833, 7834, 7, 15, 0, 0, 7834, 7835, 5, 95, 0, 0, 7835, 7836, + 7, 3, 0, 0, 7836, 7837, 7, 9, 0, 0, 7837, 7838, 7, 14, 0, 0, 7838, 7839, + 7, 4, 0, 0, 7839, 7840, 7, 21, 0, 0, 7840, 7841, 7, 8, 0, 0, 7841, 7842, + 7, 6, 0, 0, 7842, 7843, 7, 24, 0, 0, 7843, 7844, 7, 9, 0, 0, 7844, 924, + 1, 0, 0, 0, 7845, 7846, 7, 19, 0, 0, 7846, 7847, 7, 0, 0, 0, 7847, 7848, + 7, 11, 0, 0, 7848, 7849, 7, 9, 0, 0, 7849, 7850, 7, 3, 0, 0, 7850, 7851, + 7, 6, 0, 0, 7851, 7852, 7, 0, 0, 0, 7852, 7853, 7, 20, 0, 0, 7853, 7854, + 7, 6, 0, 0, 7854, 7855, 7, 24, 0, 0, 7855, 7856, 7, 9, 0, 0, 7856, 7857, + 7, 1, 0, 0, 7857, 926, 1, 0, 0, 0, 7858, 7859, 7, 19, 0, 0, 7859, 7860, + 7, 0, 0, 0, 7860, 7861, 7, 23, 0, 0, 7861, 7862, 5, 95, 0, 0, 7862, 7863, + 7, 10, 0, 0, 7863, 7864, 7, 0, 0, 0, 7864, 7865, 7, 11, 0, 0, 7865, 7866, + 7, 14, 0, 0, 7866, 7867, 7, 15, 0, 0, 7867, 7868, 5, 95, 0, 0, 7868, 7869, + 7, 3, 0, 0, 7869, 7870, 7, 4, 0, 0, 7870, 7871, 7, 13, 0, 0, 7871, 7872, + 7, 7, 0, 0, 7872, 928, 1, 0, 0, 0, 7873, 7874, 7, 19, 0, 0, 7874, 7875, + 7, 0, 0, 0, 7875, 7876, 7, 23, 0, 0, 7876, 7877, 5, 95, 0, 0, 7877, 7878, + 7, 14, 0, 0, 7878, 7879, 7, 20, 0, 0, 7879, 7880, 7, 17, 0, 0, 7880, 7881, + 7, 7, 0, 0, 7881, 7882, 7, 11, 0, 0, 7882, 7883, 7, 9, 0, 0, 7883, 7884, + 7, 3, 0, 0, 7884, 7885, 5, 95, 0, 0, 7885, 7886, 7, 14, 0, 0, 7886, 7887, + 7, 4, 0, 0, 7887, 7888, 7, 17, 0, 0, 7888, 7889, 7, 8, 0, 0, 7889, 7890, + 7, 11, 0, 0, 7890, 930, 1, 0, 0, 0, 7891, 7892, 7, 19, 0, 0, 7892, 7893, + 7, 0, 0, 0, 7893, 7894, 7, 23, 0, 0, 7894, 7895, 5, 95, 0, 0, 7895, 7896, + 7, 14, 0, 0, 7896, 7897, 7, 4, 0, 0, 7897, 7898, 7, 8, 0, 0, 7898, 7899, + 7, 14, 0, 0, 7899, 7900, 7, 17, 0, 0, 7900, 7901, 7, 3, 0, 0, 7901, 7902, + 7, 3, 0, 0, 7902, 7903, 7, 9, 0, 0, 7903, 7904, 7, 8, 0, 0, 7904, 7905, + 7, 14, 0, 0, 7905, 7906, 7, 18, 0, 0, 7906, 7907, 5, 95, 0, 0, 7907, 7908, + 7, 20, 0, 0, 7908, 7909, 7, 9, 0, 0, 7909, 7910, 7, 5, 0, 0, 7910, 7911, + 7, 9, 0, 0, 7911, 7912, 7, 20, 0, 0, 7912, 932, 1, 0, 0, 0, 7913, 7914, + 7, 19, 0, 0, 7914, 7915, 7, 0, 0, 0, 7915, 7916, 7, 23, 0, 0, 7916, 7917, + 5, 95, 0, 0, 7917, 7918, 7, 1, 0, 0, 7918, 7919, 7, 0, 0, 0, 7919, 7920, + 7, 11, 0, 0, 7920, 7921, 7, 0, 0, 0, 7921, 7922, 5, 95, 0, 0, 7922, 7923, + 7, 9, 0, 0, 7923, 7924, 7, 23, 0, 0, 7924, 7925, 7, 11, 0, 0, 7925, 7926, + 7, 9, 0, 0, 7926, 7927, 7, 8, 0, 0, 7927, 7928, 7, 7, 0, 0, 7928, 7929, + 7, 6, 0, 0, 7929, 7930, 7, 4, 0, 0, 7930, 7931, 7, 8, 0, 0, 7931, 7932, + 5, 95, 0, 0, 7932, 7933, 7, 11, 0, 0, 7933, 7934, 7, 6, 0, 0, 7934, 7935, + 7, 19, 0, 0, 7935, 7936, 7, 9, 0, 0, 7936, 7937, 5, 95, 0, 0, 7937, 7938, + 7, 6, 0, 0, 7938, 7939, 7, 8, 0, 0, 7939, 7940, 5, 95, 0, 0, 7940, 7941, + 7, 1, 0, 0, 7941, 7942, 7, 0, 0, 0, 7942, 7943, 7, 18, 0, 0, 7943, 7944, + 7, 7, 0, 0, 7944, 934, 1, 0, 0, 0, 7945, 7946, 7, 19, 0, 0, 7946, 7947, + 7, 0, 0, 0, 7947, 7948, 7, 23, 0, 0, 7948, 7949, 5, 95, 0, 0, 7949, 7950, + 7, 7, 0, 0, 7950, 7951, 7, 6, 0, 0, 7951, 7952, 7, 24, 0, 0, 7952, 7953, + 7, 9, 0, 0, 7953, 936, 1, 0, 0, 0, 7954, 7955, 7, 19, 0, 0, 7955, 7956, + 7, 9, 0, 0, 7956, 7957, 7, 0, 0, 0, 7957, 7958, 7, 7, 0, 0, 7958, 7959, + 7, 17, 0, 0, 7959, 7960, 7, 3, 0, 0, 7960, 7961, 7, 9, 0, 0, 7961, 7962, + 7, 7, 0, 0, 7962, 938, 1, 0, 0, 0, 7963, 7964, 7, 19, 0, 0, 7964, 7965, + 7, 9, 0, 0, 7965, 7966, 7, 1, 0, 0, 7966, 7967, 7, 6, 0, 0, 7967, 7968, + 7, 17, 0, 0, 7968, 7969, 7, 19, 0, 0, 7969, 940, 1, 0, 0, 0, 7970, 7971, + 7, 19, 0, 0, 7971, 7972, 7, 9, 0, 0, 7972, 7973, 7, 19, 0, 0, 7973, 7974, + 7, 4, 0, 0, 7974, 7975, 7, 6, 0, 0, 7975, 7976, 7, 24, 0, 0, 7976, 7977, + 7, 0, 0, 0, 7977, 7978, 7, 10, 0, 0, 7978, 7979, 7, 20, 0, 0, 7979, 7980, + 7, 9, 0, 0, 7980, 942, 1, 0, 0, 0, 7981, 7982, 7, 19, 0, 0, 7982, 7983, + 7, 9, 0, 0, 7983, 7984, 7, 3, 0, 0, 7984, 7985, 7, 21, 0, 0, 7985, 7986, + 7, 9, 0, 0, 7986, 944, 1, 0, 0, 0, 7987, 7988, 7, 19, 0, 0, 7988, 7989, + 7, 6, 0, 0, 7989, 7990, 7, 1, 0, 0, 7990, 7991, 7, 1, 0, 0, 7991, 7992, + 7, 20, 0, 0, 7992, 7993, 7, 9, 0, 0, 7993, 7994, 5, 95, 0, 0, 7994, 7995, + 7, 8, 0, 0, 7995, 7996, 7, 0, 0, 0, 7996, 7997, 7, 19, 0, 0, 7997, 7998, + 7, 9, 0, 0, 7998, 946, 1, 0, 0, 0, 7999, 8000, 7, 19, 0, 0, 8000, 8001, + 7, 6, 0, 0, 8001, 8002, 7, 8, 0, 0, 8002, 948, 1, 0, 0, 0, 8003, 8004, + 7, 19, 0, 0, 8004, 8005, 7, 6, 0, 0, 8005, 8006, 7, 8, 0, 0, 8006, 8007, + 7, 7, 0, 0, 8007, 8008, 5, 95, 0, 0, 8008, 8009, 7, 11, 0, 0, 8009, 8010, + 7, 4, 0, 0, 8010, 8011, 5, 95, 0, 0, 8011, 8012, 7, 10, 0, 0, 8012, 8013, + 7, 18, 0, 0, 8013, 8014, 7, 2, 0, 0, 8014, 8015, 7, 0, 0, 0, 8015, 8016, + 7, 7, 0, 0, 8016, 8017, 7, 7, 0, 0, 8017, 8018, 5, 95, 0, 0, 8018, 8019, + 7, 19, 0, 0, 8019, 8020, 7, 12, 0, 0, 8020, 8021, 7, 0, 0, 0, 8021, 950, + 1, 0, 0, 0, 8022, 8023, 7, 19, 0, 0, 8023, 8024, 7, 6, 0, 0, 8024, 8025, + 7, 8, 0, 0, 8025, 8026, 7, 7, 0, 0, 8026, 8027, 5, 95, 0, 0, 8027, 8028, + 7, 11, 0, 0, 8028, 8029, 7, 4, 0, 0, 8029, 8030, 5, 95, 0, 0, 8030, 8031, + 7, 17, 0, 0, 8031, 8032, 7, 8, 0, 0, 8032, 8033, 7, 20, 0, 0, 8033, 8034, + 7, 4, 0, 0, 8034, 8035, 7, 14, 0, 0, 8035, 8036, 7, 22, 0, 0, 8036, 952, + 1, 0, 0, 0, 8037, 8038, 7, 19, 0, 0, 8038, 8039, 7, 6, 0, 0, 8039, 8040, + 7, 8, 0, 0, 8040, 8041, 7, 17, 0, 0, 8041, 8042, 7, 7, 0, 0, 8042, 954, + 1, 0, 0, 0, 8043, 8044, 7, 19, 0, 0, 8044, 8045, 7, 6, 0, 0, 8045, 8046, + 7, 8, 0, 0, 8046, 8047, 7, 17, 0, 0, 8047, 8048, 7, 11, 0, 0, 8048, 8049, + 7, 9, 0, 0, 8049, 8050, 7, 7, 0, 0, 8050, 956, 1, 0, 0, 0, 8051, 8052, + 7, 19, 0, 0, 8052, 8053, 7, 6, 0, 0, 8053, 8054, 7, 8, 0, 0, 8054, 8055, + 5, 95, 0, 0, 8055, 8056, 7, 14, 0, 0, 8056, 8057, 7, 20, 0, 0, 8057, 8058, + 7, 17, 0, 0, 8058, 8059, 7, 7, 0, 0, 8059, 8060, 7, 11, 0, 0, 8060, 8061, + 7, 9, 0, 0, 8061, 8062, 7, 3, 0, 0, 8062, 8063, 5, 95, 0, 0, 8063, 8064, + 7, 14, 0, 0, 8064, 8065, 7, 4, 0, 0, 8065, 8066, 7, 17, 0, 0, 8066, 8067, + 7, 8, 0, 0, 8067, 8068, 7, 11, 0, 0, 8068, 958, 1, 0, 0, 0, 8069, 8070, + 7, 19, 0, 0, 8070, 8071, 7, 6, 0, 0, 8071, 8072, 7, 8, 0, 0, 8072, 8073, + 5, 95, 0, 0, 8073, 8074, 7, 1, 0, 0, 8074, 8075, 7, 0, 0, 0, 8075, 8076, + 7, 11, 0, 0, 8076, 8077, 7, 0, 0, 0, 8077, 8078, 5, 95, 0, 0, 8078, 8079, + 7, 3, 0, 0, 8079, 8080, 7, 9, 0, 0, 8080, 8081, 7, 11, 0, 0, 8081, 8082, + 7, 9, 0, 0, 8082, 8083, 7, 8, 0, 0, 8083, 8084, 7, 11, 0, 0, 8084, 8085, + 7, 6, 0, 0, 8085, 8086, 7, 4, 0, 0, 8086, 8087, 7, 8, 0, 0, 8087, 8088, + 5, 95, 0, 0, 8088, 8089, 7, 11, 0, 0, 8089, 8090, 7, 6, 0, 0, 8090, 8091, + 7, 19, 0, 0, 8091, 8092, 7, 9, 0, 0, 8092, 8093, 5, 95, 0, 0, 8093, 8094, + 7, 6, 0, 0, 8094, 8095, 7, 8, 0, 0, 8095, 8096, 5, 95, 0, 0, 8096, 8097, + 7, 1, 0, 0, 8097, 8098, 7, 0, 0, 0, 8098, 8099, 7, 18, 0, 0, 8099, 8100, + 7, 7, 0, 0, 8100, 960, 1, 0, 0, 0, 8101, 8102, 7, 19, 0, 0, 8102, 8103, + 7, 4, 0, 0, 8103, 8104, 7, 1, 0, 0, 8104, 8105, 7, 9, 0, 0, 8105, 962, + 1, 0, 0, 0, 8106, 8107, 7, 19, 0, 0, 8107, 8108, 7, 4, 0, 0, 8108, 8109, + 7, 1, 0, 0, 8109, 8110, 7, 6, 0, 0, 8110, 8111, 7, 12, 0, 0, 8111, 8112, + 7, 6, 0, 0, 8112, 8113, 7, 9, 0, 0, 8113, 8114, 7, 1, 0, 0, 8114, 8115, + 5, 95, 0, 0, 8115, 8116, 7, 0, 0, 0, 8116, 8117, 7, 12, 0, 0, 8117, 8118, + 7, 11, 0, 0, 8118, 8119, 7, 9, 0, 0, 8119, 8120, 7, 3, 0, 0, 8120, 964, + 1, 0, 0, 0, 8121, 8122, 7, 19, 0, 0, 8122, 8123, 7, 4, 0, 0, 8123, 8124, + 7, 1, 0, 0, 8124, 8125, 7, 6, 0, 0, 8125, 8126, 7, 12, 0, 0, 8126, 8127, + 7, 18, 0, 0, 8127, 966, 1, 0, 0, 0, 8128, 8129, 7, 19, 0, 0, 8129, 8130, + 7, 4, 0, 0, 8130, 8131, 7, 8, 0, 0, 8131, 8132, 7, 6, 0, 0, 8132, 8133, + 7, 11, 0, 0, 8133, 8134, 7, 4, 0, 0, 8134, 8135, 7, 3, 0, 0, 8135, 968, + 1, 0, 0, 0, 8136, 8137, 7, 19, 0, 0, 8137, 8138, 7, 4, 0, 0, 8138, 8139, + 7, 8, 0, 0, 8139, 8140, 7, 6, 0, 0, 8140, 8141, 7, 11, 0, 0, 8141, 8142, + 7, 4, 0, 0, 8142, 8143, 7, 3, 0, 0, 8143, 8144, 7, 7, 0, 0, 8144, 970, + 1, 0, 0, 0, 8145, 8146, 7, 19, 0, 0, 8146, 8147, 7, 4, 0, 0, 8147, 8148, + 7, 8, 0, 0, 8148, 8149, 7, 11, 0, 0, 8149, 8150, 7, 15, 0, 0, 8150, 8151, + 7, 20, 0, 0, 8151, 8152, 7, 18, 0, 0, 8152, 972, 1, 0, 0, 0, 8153, 8154, + 7, 19, 0, 0, 8154, 8155, 7, 4, 0, 0, 8155, 8156, 7, 5, 0, 0, 8156, 8157, + 7, 9, 0, 0, 8157, 974, 1, 0, 0, 0, 8158, 8159, 7, 19, 0, 0, 8159, 8160, + 7, 17, 0, 0, 8160, 8161, 7, 20, 0, 0, 8161, 8162, 7, 11, 0, 0, 8162, 8163, + 7, 6, 0, 0, 8163, 8164, 5, 95, 0, 0, 8164, 8165, 7, 7, 0, 0, 8165, 8166, + 7, 11, 0, 0, 8166, 8167, 7, 0, 0, 0, 8167, 8168, 7, 11, 0, 0, 8168, 8169, + 7, 9, 0, 0, 8169, 8170, 7, 19, 0, 0, 8170, 8171, 7, 9, 0, 0, 8171, 8172, + 7, 8, 0, 0, 8172, 8173, 7, 11, 0, 0, 8173, 8174, 5, 95, 0, 0, 8174, 8175, + 7, 14, 0, 0, 8175, 8176, 7, 4, 0, 0, 8176, 8177, 7, 17, 0, 0, 8177, 8178, + 7, 8, 0, 0, 8178, 8179, 7, 11, 0, 0, 8179, 976, 1, 0, 0, 0, 8180, 8181, + 7, 19, 0, 0, 8181, 8182, 7, 17, 0, 0, 8182, 8183, 7, 20, 0, 0, 8183, 8184, + 7, 11, 0, 0, 8184, 8185, 7, 6, 0, 0, 8185, 8186, 5, 95, 0, 0, 8186, 8187, + 7, 17, 0, 0, 8187, 8188, 7, 7, 0, 0, 8188, 8189, 7, 9, 0, 0, 8189, 8190, + 7, 3, 0, 0, 8190, 978, 1, 0, 0, 0, 8191, 8192, 7, 19, 0, 0, 8192, 8193, + 7, 17, 0, 0, 8193, 8194, 7, 7, 0, 0, 8194, 8195, 7, 11, 0, 0, 8195, 8196, + 5, 95, 0, 0, 8196, 8197, 7, 14, 0, 0, 8197, 8198, 7, 15, 0, 0, 8198, 8199, + 7, 0, 0, 0, 8199, 8200, 7, 8, 0, 0, 8200, 8201, 7, 21, 0, 0, 8201, 8202, + 7, 9, 0, 0, 8202, 980, 1, 0, 0, 0, 8203, 8204, 7, 19, 0, 0, 8204, 8205, + 7, 17, 0, 0, 8205, 8206, 7, 7, 0, 0, 8206, 8207, 7, 11, 0, 0, 8207, 8208, + 5, 95, 0, 0, 8208, 8209, 7, 14, 0, 0, 8209, 8210, 7, 15, 0, 0, 8210, 8211, + 7, 0, 0, 0, 8211, 8212, 7, 8, 0, 0, 8212, 8213, 7, 21, 0, 0, 8213, 8214, + 7, 9, 0, 0, 8214, 8215, 5, 95, 0, 0, 8215, 8216, 7, 2, 0, 0, 8216, 8217, + 7, 0, 0, 0, 8217, 8218, 7, 7, 0, 0, 8218, 8219, 7, 7, 0, 0, 8219, 8220, + 7, 13, 0, 0, 8220, 8221, 7, 4, 0, 0, 8221, 8222, 7, 3, 0, 0, 8222, 8223, + 7, 1, 0, 0, 8223, 982, 1, 0, 0, 0, 8224, 8225, 7, 8, 0, 0, 8225, 8226, + 7, 0, 0, 0, 8226, 8227, 7, 19, 0, 0, 8227, 8228, 7, 9, 0, 0, 8228, 984, + 1, 0, 0, 0, 8229, 8230, 7, 8, 0, 0, 8230, 8231, 7, 0, 0, 0, 8231, 8232, + 7, 11, 0, 0, 8232, 8233, 7, 17, 0, 0, 8233, 8234, 7, 3, 0, 0, 8234, 8235, + 7, 0, 0, 0, 8235, 8236, 7, 20, 0, 0, 8236, 986, 1, 0, 0, 0, 8237, 8238, + 7, 8, 0, 0, 8238, 8239, 7, 14, 0, 0, 8239, 8240, 7, 15, 0, 0, 8240, 8241, + 7, 0, 0, 0, 8241, 8242, 7, 3, 0, 0, 8242, 988, 1, 0, 0, 0, 8243, 8244, + 7, 8, 0, 0, 8244, 8245, 7, 9, 0, 0, 8245, 8246, 7, 7, 0, 0, 8246, 8247, + 7, 11, 0, 0, 8247, 8248, 7, 9, 0, 0, 8248, 8249, 7, 1, 0, 0, 8249, 8250, + 5, 95, 0, 0, 8250, 8251, 7, 11, 0, 0, 8251, 8252, 7, 3, 0, 0, 8252, 8253, + 7, 6, 0, 0, 8253, 8254, 7, 21, 0, 0, 8254, 8255, 7, 21, 0, 0, 8255, 8256, + 7, 9, 0, 0, 8256, 8257, 7, 3, 0, 0, 8257, 8258, 7, 7, 0, 0, 8258, 990, + 1, 0, 0, 0, 8259, 8260, 7, 8, 0, 0, 8260, 8261, 7, 9, 0, 0, 8261, 8262, + 7, 11, 0, 0, 8262, 8263, 7, 13, 0, 0, 8263, 8264, 7, 4, 0, 0, 8264, 8265, + 7, 3, 0, 0, 8265, 8266, 7, 22, 0, 0, 8266, 992, 1, 0, 0, 0, 8267, 8268, + 7, 8, 0, 0, 8268, 8269, 7, 9, 0, 0, 8269, 8270, 7, 11, 0, 0, 8270, 8271, + 7, 13, 0, 0, 8271, 8272, 7, 4, 0, 0, 8272, 8273, 7, 3, 0, 0, 8273, 8274, + 7, 22, 0, 0, 8274, 8275, 5, 95, 0, 0, 8275, 8276, 7, 2, 0, 0, 8276, 8277, + 7, 4, 0, 0, 8277, 8278, 7, 20, 0, 0, 8278, 8279, 7, 6, 0, 0, 8279, 8280, + 7, 14, 0, 0, 8280, 8281, 7, 18, 0, 0, 8281, 994, 1, 0, 0, 0, 8282, 8283, + 7, 8, 0, 0, 8283, 8284, 7, 9, 0, 0, 8284, 8285, 7, 5, 0, 0, 8285, 8286, + 7, 9, 0, 0, 8286, 8287, 7, 3, 0, 0, 8287, 996, 1, 0, 0, 0, 8288, 8289, + 7, 8, 0, 0, 8289, 8290, 7, 9, 0, 0, 8290, 8291, 7, 13, 0, 0, 8291, 8292, + 7, 6, 0, 0, 8292, 8293, 7, 1, 0, 0, 8293, 998, 1, 0, 0, 0, 8294, 8295, + 7, 8, 0, 0, 8295, 8296, 7, 9, 0, 0, 8296, 8297, 7, 13, 0, 0, 8297, 8298, + 7, 8, 0, 0, 8298, 8299, 7, 0, 0, 0, 8299, 8300, 7, 19, 0, 0, 8300, 8301, + 7, 9, 0, 0, 8301, 1000, 1, 0, 0, 0, 8302, 8303, 7, 8, 0, 0, 8303, 8304, + 7, 9, 0, 0, 8304, 8305, 7, 13, 0, 0, 8305, 8306, 7, 7, 0, 0, 8306, 8307, + 7, 9, 0, 0, 8307, 8308, 7, 16, 0, 0, 8308, 8309, 7, 17, 0, 0, 8309, 8310, + 7, 9, 0, 0, 8310, 8311, 7, 8, 0, 0, 8311, 8312, 7, 11, 0, 0, 8312, 8313, + 7, 6, 0, 0, 8313, 8314, 7, 0, 0, 0, 8314, 8315, 7, 20, 0, 0, 8315, 8316, + 7, 6, 0, 0, 8316, 8317, 7, 1, 0, 0, 8317, 1002, 1, 0, 0, 0, 8318, 8319, + 7, 8, 0, 0, 8319, 8320, 7, 9, 0, 0, 8320, 8321, 7, 13, 0, 0, 8321, 8322, + 5, 95, 0, 0, 8322, 8323, 7, 0, 0, 0, 8323, 8324, 7, 14, 0, 0, 8324, 8325, + 7, 14, 0, 0, 8325, 8326, 7, 4, 0, 0, 8326, 8327, 7, 17, 0, 0, 8327, 8328, + 7, 8, 0, 0, 8328, 8329, 7, 11, 0, 0, 8329, 1004, 1, 0, 0, 0, 8330, 8331, + 7, 8, 0, 0, 8331, 8332, 7, 9, 0, 0, 8332, 8333, 7, 13, 0, 0, 8333, 8334, + 5, 95, 0, 0, 8334, 8335, 7, 10, 0, 0, 8335, 8336, 7, 3, 0, 0, 8336, 8337, + 7, 4, 0, 0, 8337, 8338, 7, 22, 0, 0, 8338, 8339, 7, 9, 0, 0, 8339, 8340, + 7, 3, 0, 0, 8340, 1006, 1, 0, 0, 0, 8341, 8342, 7, 8, 0, 0, 8342, 8343, + 7, 9, 0, 0, 8343, 8344, 7, 13, 0, 0, 8344, 8345, 5, 95, 0, 0, 8345, 8346, + 7, 2, 0, 0, 8346, 8347, 7, 0, 0, 0, 8347, 8348, 7, 7, 0, 0, 8348, 8349, + 7, 7, 0, 0, 8349, 8350, 7, 13, 0, 0, 8350, 8351, 7, 4, 0, 0, 8351, 8352, + 7, 3, 0, 0, 8352, 8353, 7, 1, 0, 0, 8353, 1008, 1, 0, 0, 0, 8354, 8355, + 7, 8, 0, 0, 8355, 8356, 7, 9, 0, 0, 8356, 8357, 7, 23, 0, 0, 8357, 8358, + 7, 11, 0, 0, 8358, 1010, 1, 0, 0, 0, 8359, 8360, 7, 8, 0, 0, 8360, 8361, + 7, 9, 0, 0, 8361, 8362, 7, 23, 0, 0, 8362, 8363, 7, 11, 0, 0, 8363, 8364, + 7, 5, 0, 0, 8364, 8365, 7, 0, 0, 0, 8365, 8366, 7, 20, 0, 0, 8366, 1012, + 1, 0, 0, 0, 8367, 8368, 7, 8, 0, 0, 8368, 8369, 7, 4, 0, 0, 8369, 1014, + 1, 0, 0, 0, 8370, 8371, 7, 8, 0, 0, 8371, 8372, 7, 4, 0, 0, 8372, 8373, + 7, 8, 0, 0, 8373, 8374, 7, 9, 0, 0, 8374, 1016, 1, 0, 0, 0, 8375, 8376, + 5, 39, 0, 0, 8376, 8377, 7, 8, 0, 0, 8377, 8378, 7, 4, 0, 0, 8378, 8379, + 7, 8, 0, 0, 8379, 8380, 7, 9, 0, 0, 8380, 8381, 5, 39, 0, 0, 8381, 1018, + 1, 0, 0, 0, 8382, 8383, 7, 8, 0, 0, 8383, 8384, 7, 4, 0, 0, 8384, 8385, + 7, 3, 0, 0, 8385, 8386, 7, 9, 0, 0, 8386, 8387, 7, 20, 0, 0, 8387, 8388, + 7, 18, 0, 0, 8388, 1020, 1, 0, 0, 0, 8389, 8390, 7, 8, 0, 0, 8390, 8391, + 7, 4, 0, 0, 8391, 8392, 7, 11, 0, 0, 8392, 1022, 1, 0, 0, 0, 8393, 8394, + 7, 8, 0, 0, 8394, 8395, 7, 4, 0, 0, 8395, 8396, 7, 11, 0, 0, 8396, 8397, + 7, 6, 0, 0, 8397, 8398, 7, 12, 0, 0, 8398, 8399, 7, 6, 0, 0, 8399, 8400, + 7, 14, 0, 0, 8400, 8401, 7, 0, 0, 0, 8401, 8402, 7, 11, 0, 0, 8402, 8403, + 7, 6, 0, 0, 8403, 8404, 7, 4, 0, 0, 8404, 8405, 7, 8, 0, 0, 8405, 1024, + 1, 0, 0, 0, 8406, 8407, 7, 8, 0, 0, 8407, 8408, 7, 4, 0, 0, 8408, 8409, + 7, 11, 0, 0, 8409, 8410, 7, 6, 0, 0, 8410, 8411, 7, 12, 0, 0, 8411, 8412, + 7, 6, 0, 0, 8412, 8413, 7, 14, 0, 0, 8413, 8414, 7, 0, 0, 0, 8414, 8415, + 7, 11, 0, 0, 8415, 8416, 7, 6, 0, 0, 8416, 8417, 7, 4, 0, 0, 8417, 8418, + 7, 8, 0, 0, 8418, 8419, 7, 7, 0, 0, 8419, 1026, 1, 0, 0, 0, 8420, 8421, + 7, 8, 0, 0, 8421, 8422, 7, 4, 0, 0, 8422, 8423, 7, 11, 0, 0, 8423, 8424, + 7, 6, 0, 0, 8424, 8425, 7, 12, 0, 0, 8425, 8426, 7, 6, 0, 0, 8426, 8427, + 7, 14, 0, 0, 8427, 8428, 7, 0, 0, 0, 8428, 8429, 7, 11, 0, 0, 8429, 8430, + 7, 6, 0, 0, 8430, 8431, 7, 4, 0, 0, 8431, 8432, 7, 8, 0, 0, 8432, 8433, + 5, 95, 0, 0, 8433, 8434, 7, 6, 0, 0, 8434, 8435, 7, 8, 0, 0, 8435, 8436, + 7, 11, 0, 0, 8436, 8437, 7, 9, 0, 0, 8437, 8438, 7, 21, 0, 0, 8438, 8439, + 7, 3, 0, 0, 8439, 8440, 7, 0, 0, 0, 8440, 8441, 7, 11, 0, 0, 8441, 8442, + 7, 6, 0, 0, 8442, 8443, 7, 4, 0, 0, 8443, 8444, 7, 8, 0, 0, 8444, 1028, + 1, 0, 0, 0, 8445, 8446, 7, 8, 0, 0, 8446, 8447, 7, 4, 0, 0, 8447, 8448, + 7, 11, 0, 0, 8448, 8449, 7, 6, 0, 0, 8449, 8450, 7, 12, 0, 0, 8450, 8451, + 7, 6, 0, 0, 8451, 8452, 7, 14, 0, 0, 8452, 8453, 7, 0, 0, 0, 8453, 8454, + 7, 11, 0, 0, 8454, 8455, 7, 6, 0, 0, 8455, 8456, 7, 4, 0, 0, 8456, 8457, + 7, 8, 0, 0, 8457, 8458, 5, 95, 0, 0, 8458, 8459, 7, 2, 0, 0, 8459, 8460, + 7, 3, 0, 0, 8460, 8461, 7, 4, 0, 0, 8461, 8462, 7, 5, 0, 0, 8462, 8463, + 7, 6, 0, 0, 8463, 8464, 7, 1, 0, 0, 8464, 8465, 7, 9, 0, 0, 8465, 8466, + 7, 3, 0, 0, 8466, 1030, 1, 0, 0, 0, 8467, 8468, 7, 8, 0, 0, 8468, 8469, + 7, 4, 0, 0, 8469, 8470, 7, 11, 0, 0, 8470, 8471, 7, 6, 0, 0, 8471, 8472, + 7, 12, 0, 0, 8472, 8473, 7, 18, 0, 0, 8473, 1032, 1, 0, 0, 0, 8474, 8475, + 7, 8, 0, 0, 8475, 8476, 7, 4, 0, 0, 8476, 8477, 7, 11, 0, 0, 8477, 8478, + 7, 6, 0, 0, 8478, 8479, 7, 12, 0, 0, 8479, 8480, 7, 18, 0, 0, 8480, 8481, + 5, 95, 0, 0, 8481, 8482, 7, 17, 0, 0, 8482, 8483, 7, 7, 0, 0, 8483, 8484, + 7, 9, 0, 0, 8484, 8485, 7, 3, 0, 0, 8485, 8486, 7, 7, 0, 0, 8486, 1034, + 1, 0, 0, 0, 8487, 8488, 7, 8, 0, 0, 8488, 8489, 7, 4, 0, 0, 8489, 8490, + 7, 5, 0, 0, 8490, 8491, 7, 0, 0, 0, 8491, 8492, 7, 20, 0, 0, 8492, 8493, + 7, 6, 0, 0, 8493, 8494, 7, 1, 0, 0, 8494, 8495, 7, 0, 0, 0, 8495, 8496, + 7, 11, 0, 0, 8496, 8497, 7, 9, 0, 0, 8497, 1036, 1, 0, 0, 0, 8498, 8499, + 7, 8, 0, 0, 8499, 8500, 7, 11, 0, 0, 8500, 8501, 7, 6, 0, 0, 8501, 8502, + 7, 20, 0, 0, 8502, 8503, 7, 9, 0, 0, 8503, 1038, 1, 0, 0, 0, 8504, 8505, + 7, 8, 0, 0, 8505, 8506, 7, 17, 0, 0, 8506, 8507, 7, 20, 0, 0, 8507, 8508, + 7, 20, 0, 0, 8508, 8509, 7, 6, 0, 0, 8509, 8510, 7, 12, 0, 0, 8510, 1040, + 1, 0, 0, 0, 8511, 8512, 7, 8, 0, 0, 8512, 8513, 7, 17, 0, 0, 8513, 8514, + 7, 20, 0, 0, 8514, 8515, 7, 20, 0, 0, 8515, 8516, 7, 7, 0, 0, 8516, 1042, + 1, 0, 0, 0, 8517, 8518, 7, 8, 0, 0, 8518, 8519, 7, 17, 0, 0, 8519, 8520, + 7, 20, 0, 0, 8520, 8521, 7, 20, 0, 0, 8521, 1044, 1, 0, 0, 0, 8522, 8523, + 7, 8, 0, 0, 8523, 8524, 7, 17, 0, 0, 8524, 8525, 7, 20, 0, 0, 8525, 8526, + 7, 20, 0, 0, 8526, 8527, 5, 95, 0, 0, 8527, 8528, 7, 6, 0, 0, 8528, 8529, + 7, 12, 0, 0, 8529, 1046, 1, 0, 0, 0, 8530, 8531, 7, 8, 0, 0, 8531, 8532, + 7, 17, 0, 0, 8532, 8533, 7, 19, 0, 0, 8533, 8534, 7, 0, 0, 0, 8534, 8535, + 7, 8, 0, 0, 8535, 8536, 7, 4, 0, 0, 8536, 8537, 7, 1, 0, 0, 8537, 8538, + 7, 9, 0, 0, 8538, 1048, 1, 0, 0, 0, 8539, 8540, 7, 8, 0, 0, 8540, 8541, + 7, 17, 0, 0, 8541, 8542, 7, 19, 0, 0, 8542, 8543, 7, 10, 0, 0, 8543, 8544, + 7, 9, 0, 0, 8544, 8545, 7, 3, 0, 0, 8545, 1050, 1, 0, 0, 0, 8546, 8547, + 7, 8, 0, 0, 8547, 8548, 7, 17, 0, 0, 8548, 8549, 7, 19, 0, 0, 8549, 8550, + 7, 9, 0, 0, 8550, 8551, 7, 3, 0, 0, 8551, 8552, 7, 6, 0, 0, 8552, 8553, + 7, 14, 0, 0, 8553, 8554, 5, 95, 0, 0, 8554, 8555, 7, 3, 0, 0, 8555, 8556, + 7, 4, 0, 0, 8556, 8557, 7, 17, 0, 0, 8557, 8558, 7, 8, 0, 0, 8558, 8559, + 7, 1, 0, 0, 8559, 8560, 7, 0, 0, 0, 8560, 8561, 7, 10, 0, 0, 8561, 8562, + 7, 4, 0, 0, 8562, 8563, 7, 3, 0, 0, 8563, 8564, 7, 11, 0, 0, 8564, 1052, + 1, 0, 0, 0, 8565, 8566, 7, 8, 0, 0, 8566, 8567, 7, 5, 0, 0, 8567, 8568, + 7, 20, 0, 0, 8568, 1054, 1, 0, 0, 0, 8569, 8570, 7, 4, 0, 0, 8570, 8571, + 7, 0, 0, 0, 8571, 8572, 7, 17, 0, 0, 8572, 8573, 7, 11, 0, 0, 8573, 8574, + 7, 15, 0, 0, 8574, 1056, 1, 0, 0, 0, 8575, 8576, 7, 4, 0, 0, 8576, 8577, + 7, 0, 0, 0, 8577, 8578, 7, 17, 0, 0, 8578, 8579, 7, 11, 0, 0, 8579, 8580, + 7, 15, 0, 0, 8580, 8581, 5, 95, 0, 0, 8581, 8582, 7, 0, 0, 0, 8582, 8583, + 7, 20, 0, 0, 8583, 8584, 7, 20, 0, 0, 8584, 8585, 7, 4, 0, 0, 8585, 8586, + 7, 13, 0, 0, 8586, 8587, 5, 95, 0, 0, 8587, 8588, 7, 8, 0, 0, 8588, 8589, + 7, 4, 0, 0, 8589, 8590, 7, 8, 0, 0, 8590, 8591, 5, 95, 0, 0, 8591, 8592, + 7, 11, 0, 0, 8592, 8593, 7, 20, 0, 0, 8593, 8594, 7, 7, 0, 0, 8594, 8595, + 5, 95, 0, 0, 8595, 8596, 7, 3, 0, 0, 8596, 8597, 7, 9, 0, 0, 8597, 8598, + 7, 1, 0, 0, 8598, 8599, 7, 6, 0, 0, 8599, 8600, 7, 3, 0, 0, 8600, 8601, + 7, 9, 0, 0, 8601, 8602, 7, 14, 0, 0, 8602, 8603, 7, 11, 0, 0, 8603, 8604, + 5, 95, 0, 0, 8604, 8605, 7, 17, 0, 0, 8605, 8606, 7, 3, 0, 0, 8606, 8607, + 7, 6, 0, 0, 8607, 1058, 1, 0, 0, 0, 8608, 8609, 7, 4, 0, 0, 8609, 8610, + 7, 0, 0, 0, 8610, 8611, 7, 17, 0, 0, 8611, 8612, 7, 11, 0, 0, 8612, 8613, + 7, 15, 0, 0, 8613, 8614, 5, 95, 0, 0, 8614, 8615, 7, 14, 0, 0, 8615, 8616, + 7, 20, 0, 0, 8616, 8617, 7, 6, 0, 0, 8617, 8618, 7, 9, 0, 0, 8618, 8619, + 7, 8, 0, 0, 8619, 8620, 7, 11, 0, 0, 8620, 1060, 1, 0, 0, 0, 8621, 8622, + 7, 4, 0, 0, 8622, 8623, 7, 0, 0, 0, 8623, 8624, 7, 17, 0, 0, 8624, 8625, + 7, 11, 0, 0, 8625, 8626, 7, 15, 0, 0, 8626, 8627, 5, 95, 0, 0, 8627, 8628, + 7, 14, 0, 0, 8628, 8629, 7, 20, 0, 0, 8629, 8630, 7, 6, 0, 0, 8630, 8631, + 7, 9, 0, 0, 8631, 8632, 7, 8, 0, 0, 8632, 8633, 7, 11, 0, 0, 8633, 8634, + 5, 95, 0, 0, 8634, 8635, 7, 3, 0, 0, 8635, 8636, 7, 7, 0, 0, 8636, 8637, + 7, 0, 0, 0, 8637, 8638, 5, 95, 0, 0, 8638, 8639, 7, 2, 0, 0, 8639, 8640, + 7, 17, 0, 0, 8640, 8641, 7, 10, 0, 0, 8641, 8642, 7, 20, 0, 0, 8642, 8643, + 7, 6, 0, 0, 8643, 8644, 7, 14, 0, 0, 8644, 8645, 5, 95, 0, 0, 8645, 8646, + 7, 22, 0, 0, 8646, 8647, 7, 9, 0, 0, 8647, 8648, 7, 18, 0, 0, 8648, 1062, + 1, 0, 0, 0, 8649, 8650, 7, 4, 0, 0, 8650, 8651, 7, 0, 0, 0, 8651, 8652, + 7, 17, 0, 0, 8652, 8653, 7, 11, 0, 0, 8653, 8654, 7, 15, 0, 0, 8654, 8655, + 5, 95, 0, 0, 8655, 8656, 7, 14, 0, 0, 8656, 8657, 7, 20, 0, 0, 8657, 8658, + 7, 6, 0, 0, 8658, 8659, 7, 9, 0, 0, 8659, 8660, 7, 8, 0, 0, 8660, 8661, + 7, 11, 0, 0, 8661, 8662, 5, 95, 0, 0, 8662, 8663, 7, 3, 0, 0, 8663, 8664, + 7, 7, 0, 0, 8664, 8665, 7, 0, 0, 0, 8665, 8666, 5, 95, 0, 0, 8666, 8667, + 7, 2, 0, 0, 8667, 8668, 7, 17, 0, 0, 8668, 8669, 7, 10, 0, 0, 8669, 8670, + 7, 20, 0, 0, 8670, 8671, 7, 6, 0, 0, 8671, 8672, 7, 14, 0, 0, 8672, 8673, + 5, 95, 0, 0, 8673, 8674, 7, 22, 0, 0, 8674, 8675, 7, 9, 0, 0, 8675, 8676, + 7, 18, 0, 0, 8676, 8677, 5, 95, 0, 0, 8677, 8678, 5, 50, 0, 0, 8678, 1064, + 1, 0, 0, 0, 8679, 8680, 7, 4, 0, 0, 8680, 8681, 7, 0, 0, 0, 8681, 8682, + 7, 17, 0, 0, 8682, 8683, 7, 11, 0, 0, 8683, 8684, 7, 15, 0, 0, 8684, 8685, + 5, 95, 0, 0, 8685, 8686, 7, 9, 0, 0, 8686, 8687, 7, 8, 0, 0, 8687, 8688, + 7, 12, 0, 0, 8688, 8689, 7, 4, 0, 0, 8689, 8690, 7, 3, 0, 0, 8690, 8691, + 7, 14, 0, 0, 8691, 8692, 7, 9, 0, 0, 8692, 8693, 5, 95, 0, 0, 8693, 8694, + 7, 2, 0, 0, 8694, 8695, 7, 22, 0, 0, 8695, 8696, 7, 14, 0, 0, 8696, 8697, + 7, 9, 0, 0, 8697, 1066, 1, 0, 0, 0, 8698, 8699, 7, 4, 0, 0, 8699, 8700, + 7, 0, 0, 0, 8700, 8701, 7, 17, 0, 0, 8701, 8702, 7, 11, 0, 0, 8702, 8703, + 7, 15, 0, 0, 8703, 8704, 5, 95, 0, 0, 8704, 8705, 7, 6, 0, 0, 8705, 8706, + 7, 7, 0, 0, 8706, 8707, 7, 7, 0, 0, 8707, 8708, 7, 17, 0, 0, 8708, 8709, + 7, 9, 0, 0, 8709, 8710, 5, 95, 0, 0, 8710, 8711, 7, 3, 0, 0, 8711, 8712, + 7, 9, 0, 0, 8712, 8713, 7, 12, 0, 0, 8713, 8714, 7, 3, 0, 0, 8714, 8715, + 7, 9, 0, 0, 8715, 8716, 7, 7, 0, 0, 8716, 8717, 7, 15, 0, 0, 8717, 8718, + 5, 95, 0, 0, 8718, 8719, 7, 11, 0, 0, 8719, 8720, 7, 4, 0, 0, 8720, 8721, + 7, 22, 0, 0, 8721, 8722, 7, 9, 0, 0, 8722, 8723, 7, 8, 0, 0, 8723, 8724, + 7, 7, 0, 0, 8724, 1068, 1, 0, 0, 0, 8725, 8726, 7, 4, 0, 0, 8726, 8727, + 7, 0, 0, 0, 8727, 8728, 7, 17, 0, 0, 8728, 8729, 7, 11, 0, 0, 8729, 8730, + 7, 15, 0, 0, 8730, 8731, 5, 95, 0, 0, 8731, 8732, 7, 3, 0, 0, 8732, 8733, + 7, 9, 0, 0, 8733, 8734, 7, 1, 0, 0, 8734, 8735, 7, 6, 0, 0, 8735, 8736, + 7, 3, 0, 0, 8736, 8737, 7, 9, 0, 0, 8737, 8738, 7, 14, 0, 0, 8738, 8739, + 7, 11, 0, 0, 8739, 8740, 5, 95, 0, 0, 8740, 8741, 7, 17, 0, 0, 8741, 8742, + 7, 3, 0, 0, 8742, 8743, 7, 6, 0, 0, 8743, 1070, 1, 0, 0, 0, 8744, 8745, + 7, 4, 0, 0, 8745, 8746, 7, 0, 0, 0, 8746, 8747, 7, 17, 0, 0, 8747, 8748, + 7, 11, 0, 0, 8748, 8749, 7, 15, 0, 0, 8749, 8750, 5, 95, 0, 0, 8750, 8751, + 7, 3, 0, 0, 8751, 8752, 7, 9, 0, 0, 8752, 8753, 7, 12, 0, 0, 8753, 8754, + 7, 3, 0, 0, 8754, 8755, 7, 9, 0, 0, 8755, 8756, 7, 7, 0, 0, 8756, 8757, + 7, 15, 0, 0, 8757, 8758, 5, 95, 0, 0, 8758, 8759, 7, 11, 0, 0, 8759, 8760, + 7, 4, 0, 0, 8760, 8761, 7, 22, 0, 0, 8761, 8762, 7, 9, 0, 0, 8762, 8763, + 7, 8, 0, 0, 8763, 8764, 5, 95, 0, 0, 8764, 8765, 7, 5, 0, 0, 8765, 8766, + 7, 0, 0, 0, 8766, 8767, 7, 20, 0, 0, 8767, 8768, 7, 6, 0, 0, 8768, 8769, + 7, 1, 0, 0, 8769, 8770, 7, 6, 0, 0, 8770, 8771, 7, 11, 0, 0, 8771, 8772, + 7, 18, 0, 0, 8772, 1072, 1, 0, 0, 0, 8773, 8774, 7, 4, 0, 0, 8774, 8775, + 7, 0, 0, 0, 8775, 8776, 7, 17, 0, 0, 8776, 8777, 7, 11, 0, 0, 8777, 8778, + 7, 15, 0, 0, 8778, 8779, 5, 95, 0, 0, 8779, 8780, 7, 17, 0, 0, 8780, 8781, + 7, 7, 0, 0, 8781, 8782, 7, 9, 0, 0, 8782, 8783, 5, 95, 0, 0, 8783, 8784, + 7, 7, 0, 0, 8784, 8785, 7, 9, 0, 0, 8785, 8786, 7, 14, 0, 0, 8786, 8787, + 7, 4, 0, 0, 8787, 8788, 7, 8, 0, 0, 8788, 8789, 7, 1, 0, 0, 8789, 8790, + 7, 0, 0, 0, 8790, 8791, 7, 3, 0, 0, 8791, 8792, 7, 18, 0, 0, 8792, 8793, + 5, 95, 0, 0, 8793, 8794, 7, 3, 0, 0, 8794, 8795, 7, 4, 0, 0, 8795, 8796, + 7, 20, 0, 0, 8796, 8797, 7, 9, 0, 0, 8797, 8798, 7, 7, 0, 0, 8798, 1074, + 1, 0, 0, 0, 8799, 8800, 7, 4, 0, 0, 8800, 8801, 7, 10, 0, 0, 8801, 8802, + 7, 25, 0, 0, 8802, 8803, 7, 9, 0, 0, 8803, 8804, 7, 14, 0, 0, 8804, 8805, + 7, 11, 0, 0, 8805, 1076, 1, 0, 0, 0, 8806, 8807, 5, 39, 0, 0, 8807, 8808, + 7, 4, 0, 0, 8808, 8809, 7, 10, 0, 0, 8809, 8810, 7, 25, 0, 0, 8810, 8811, + 7, 9, 0, 0, 8811, 8812, 7, 14, 0, 0, 8812, 8813, 7, 11, 0, 0, 8813, 8814, + 5, 39, 0, 0, 8814, 1078, 1, 0, 0, 0, 8815, 8816, 7, 4, 0, 0, 8816, 8817, + 7, 10, 0, 0, 8817, 8818, 7, 25, 0, 0, 8818, 8819, 7, 9, 0, 0, 8819, 8820, + 7, 14, 0, 0, 8820, 8821, 7, 11, 0, 0, 8821, 8822, 7, 7, 0, 0, 8822, 1080, + 1, 0, 0, 0, 8823, 8824, 7, 4, 0, 0, 8824, 8825, 7, 10, 0, 0, 8825, 8826, + 7, 25, 0, 0, 8826, 8827, 7, 9, 0, 0, 8827, 8828, 7, 14, 0, 0, 8828, 8829, + 7, 11, 0, 0, 8829, 8830, 5, 95, 0, 0, 8830, 8831, 7, 11, 0, 0, 8831, 8832, + 7, 18, 0, 0, 8832, 8833, 7, 2, 0, 0, 8833, 8834, 7, 9, 0, 0, 8834, 8835, + 7, 7, 0, 0, 8835, 1082, 1, 0, 0, 0, 8836, 8837, 7, 4, 0, 0, 8837, 8838, + 7, 12, 0, 0, 8838, 1084, 1, 0, 0, 0, 8839, 8840, 7, 4, 0, 0, 8840, 8841, + 7, 12, 0, 0, 8841, 8842, 7, 12, 0, 0, 8842, 1086, 1, 0, 0, 0, 8843, 8844, + 7, 4, 0, 0, 8844, 8845, 7, 12, 0, 0, 8845, 8846, 7, 12, 0, 0, 8846, 8847, + 7, 7, 0, 0, 8847, 8848, 7, 9, 0, 0, 8848, 8849, 7, 11, 0, 0, 8849, 1088, + 1, 0, 0, 0, 8850, 8851, 7, 4, 0, 0, 8851, 8852, 7, 12, 0, 0, 8852, 8853, + 7, 12, 0, 0, 8853, 8854, 7, 7, 0, 0, 8854, 8855, 7, 9, 0, 0, 8855, 8856, + 7, 11, 0, 0, 8856, 8857, 7, 7, 0, 0, 8857, 1090, 1, 0, 0, 0, 8858, 8859, + 7, 4, 0, 0, 8859, 8860, 7, 22, 0, 0, 8860, 8861, 7, 11, 0, 0, 8861, 8862, + 7, 0, 0, 0, 8862, 1092, 1, 0, 0, 0, 8863, 8864, 5, 39, 0, 0, 8864, 8865, + 7, 4, 0, 0, 8865, 8866, 7, 22, 0, 0, 8866, 8867, 7, 11, 0, 0, 8867, 8868, + 7, 0, 0, 0, 8868, 8869, 5, 95, 0, 0, 8869, 8870, 7, 2, 0, 0, 8870, 8871, + 7, 3, 0, 0, 8871, 8872, 7, 4, 0, 0, 8872, 8873, 7, 5, 0, 0, 8873, 8874, + 7, 6, 0, 0, 8874, 8875, 7, 7, 0, 0, 8875, 8876, 7, 6, 0, 0, 8876, 8877, + 7, 4, 0, 0, 8877, 8878, 7, 8, 0, 0, 8878, 8879, 7, 9, 0, 0, 8879, 8880, + 7, 3, 0, 0, 8880, 8881, 5, 39, 0, 0, 8881, 1094, 1, 0, 0, 0, 8882, 8883, + 5, 39, 0, 0, 8883, 8884, 7, 4, 0, 0, 8884, 8885, 7, 22, 0, 0, 8885, 8886, + 7, 11, 0, 0, 8886, 8887, 7, 0, 0, 0, 8887, 8888, 5, 39, 0, 0, 8888, 1096, + 1, 0, 0, 0, 8889, 8890, 7, 4, 0, 0, 8890, 8891, 7, 20, 0, 0, 8891, 8892, + 7, 1, 0, 0, 8892, 1098, 1, 0, 0, 0, 8893, 8894, 7, 4, 0, 0, 8894, 8895, + 7, 20, 0, 0, 8895, 8896, 7, 1, 0, 0, 8896, 8897, 5, 95, 0, 0, 8897, 8898, + 7, 0, 0, 0, 8898, 8899, 7, 14, 0, 0, 8899, 8900, 7, 14, 0, 0, 8900, 8901, + 7, 4, 0, 0, 8901, 8902, 7, 17, 0, 0, 8902, 8903, 7, 8, 0, 0, 8903, 8904, + 7, 11, 0, 0, 8904, 1100, 1, 0, 0, 0, 8905, 8906, 7, 4, 0, 0, 8906, 8907, + 7, 20, 0, 0, 8907, 8908, 7, 1, 0, 0, 8908, 8909, 5, 95, 0, 0, 8909, 8910, + 7, 2, 0, 0, 8910, 8911, 7, 0, 0, 0, 8911, 8912, 7, 7, 0, 0, 8912, 8913, + 7, 7, 0, 0, 8913, 8914, 7, 13, 0, 0, 8914, 8915, 7, 4, 0, 0, 8915, 8916, + 7, 3, 0, 0, 8916, 8917, 7, 1, 0, 0, 8917, 1102, 1, 0, 0, 0, 8918, 8919, + 7, 4, 0, 0, 8919, 8920, 7, 19, 0, 0, 8920, 8921, 7, 6, 0, 0, 8921, 8922, + 7, 11, 0, 0, 8922, 1104, 1, 0, 0, 0, 8923, 8924, 7, 4, 0, 0, 8924, 8925, + 7, 8, 0, 0, 8925, 1106, 1, 0, 0, 0, 8926, 8927, 7, 4, 0, 0, 8927, 8928, + 7, 8, 0, 0, 8928, 8929, 7, 9, 0, 0, 8929, 1108, 1, 0, 0, 0, 8930, 8931, + 7, 4, 0, 0, 8931, 8932, 7, 8, 0, 0, 8932, 8933, 7, 20, 0, 0, 8933, 8934, + 7, 6, 0, 0, 8934, 8935, 7, 8, 0, 0, 8935, 8936, 7, 9, 0, 0, 8936, 1110, + 1, 0, 0, 0, 8937, 8938, 7, 4, 0, 0, 8938, 8939, 7, 8, 0, 0, 8939, 8940, + 7, 20, 0, 0, 8940, 8941, 7, 18, 0, 0, 8941, 1112, 1, 0, 0, 0, 8942, 8943, + 7, 4, 0, 0, 8943, 8944, 7, 8, 0, 0, 8944, 8945, 5, 95, 0, 0, 8945, 8946, + 7, 9, 0, 0, 8946, 8947, 7, 3, 0, 0, 8947, 8948, 7, 3, 0, 0, 8948, 8949, + 7, 4, 0, 0, 8949, 8950, 7, 3, 0, 0, 8950, 1114, 1, 0, 0, 0, 8951, 8952, + 7, 4, 0, 0, 8952, 8953, 7, 8, 0, 0, 8953, 8954, 5, 95, 0, 0, 8954, 8955, + 7, 12, 0, 0, 8955, 8956, 7, 0, 0, 0, 8956, 8957, 7, 6, 0, 0, 8957, 8958, + 7, 20, 0, 0, 8958, 8959, 7, 17, 0, 0, 8959, 8960, 7, 3, 0, 0, 8960, 8961, + 7, 9, 0, 0, 8961, 1116, 1, 0, 0, 0, 8962, 8963, 7, 4, 0, 0, 8963, 8964, + 7, 2, 0, 0, 8964, 8965, 7, 9, 0, 0, 8965, 8966, 7, 8, 0, 0, 8966, 1118, + 1, 0, 0, 0, 8967, 8968, 7, 4, 0, 0, 8968, 8969, 7, 2, 0, 0, 8969, 8970, + 7, 9, 0, 0, 8970, 8971, 7, 3, 0, 0, 8971, 8972, 7, 0, 0, 0, 8972, 8973, + 7, 11, 0, 0, 8973, 8974, 7, 9, 0, 0, 8974, 1120, 1, 0, 0, 0, 8975, 8976, + 7, 4, 0, 0, 8976, 8977, 7, 2, 0, 0, 8977, 8978, 7, 9, 0, 0, 8978, 8979, + 7, 3, 0, 0, 8979, 8980, 7, 0, 0, 0, 8980, 8981, 7, 11, 0, 0, 8981, 8982, + 7, 6, 0, 0, 8982, 8983, 7, 4, 0, 0, 8983, 8984, 7, 8, 0, 0, 8984, 8985, + 7, 7, 0, 0, 8985, 1122, 1, 0, 0, 0, 8986, 8987, 7, 4, 0, 0, 8987, 8988, + 7, 2, 0, 0, 8988, 8989, 7, 11, 0, 0, 8989, 8990, 7, 6, 0, 0, 8990, 8991, + 7, 19, 0, 0, 8991, 8992, 7, 6, 0, 0, 8992, 8993, 7, 24, 0, 0, 8993, 8994, + 7, 0, 0, 0, 8994, 8995, 7, 11, 0, 0, 8995, 8996, 7, 6, 0, 0, 8996, 8997, + 7, 4, 0, 0, 8997, 8998, 7, 8, 0, 0, 8998, 1124, 1, 0, 0, 0, 8999, 9000, + 7, 4, 0, 0, 9000, 9001, 7, 2, 0, 0, 9001, 9002, 7, 11, 0, 0, 9002, 9003, + 7, 6, 0, 0, 9003, 9004, 7, 4, 0, 0, 9004, 9005, 7, 8, 0, 0, 9005, 1126, + 1, 0, 0, 0, 9006, 9007, 7, 4, 0, 0, 9007, 9008, 7, 3, 0, 0, 9008, 1128, + 1, 0, 0, 0, 9009, 9010, 7, 4, 0, 0, 9010, 9011, 7, 3, 0, 0, 9011, 9012, + 7, 14, 0, 0, 9012, 1130, 1, 0, 0, 0, 9013, 9014, 5, 39, 0, 0, 9014, 9015, + 7, 4, 0, 0, 9015, 9016, 7, 3, 0, 0, 9016, 9017, 7, 14, 0, 0, 9017, 9018, + 5, 39, 0, 0, 9018, 1132, 1, 0, 0, 0, 9019, 9020, 7, 4, 0, 0, 9020, 9021, + 7, 3, 0, 0, 9021, 9022, 7, 1, 0, 0, 9022, 9023, 7, 9, 0, 0, 9023, 9024, + 7, 3, 0, 0, 9024, 1134, 1, 0, 0, 0, 9025, 9026, 7, 4, 0, 0, 9026, 9027, + 7, 3, 0, 0, 9027, 9028, 7, 21, 0, 0, 9028, 9029, 7, 0, 0, 0, 9029, 9030, + 7, 1, 0, 0, 9030, 9031, 7, 19, 0, 0, 9031, 9032, 7, 6, 0, 0, 9032, 9033, + 7, 8, 0, 0, 9033, 1136, 1, 0, 0, 0, 9034, 9035, 7, 4, 0, 0, 9035, 9036, + 7, 3, 0, 0, 9036, 9037, 7, 21, 0, 0, 9037, 9038, 7, 0, 0, 0, 9038, 9039, + 7, 8, 0, 0, 9039, 9040, 7, 6, 0, 0, 9040, 9041, 7, 24, 0, 0, 9041, 9042, + 7, 0, 0, 0, 9042, 9043, 7, 11, 0, 0, 9043, 9044, 7, 6, 0, 0, 9044, 9045, + 7, 4, 0, 0, 9045, 9046, 7, 8, 0, 0, 9046, 1138, 1, 0, 0, 0, 9047, 9048, + 7, 4, 0, 0, 9048, 9049, 7, 17, 0, 0, 9049, 9050, 7, 11, 0, 0, 9050, 9051, + 7, 10, 0, 0, 9051, 9052, 7, 4, 0, 0, 9052, 9053, 7, 17, 0, 0, 9053, 9054, + 7, 8, 0, 0, 9054, 9055, 7, 1, 0, 0, 9055, 1140, 1, 0, 0, 0, 9056, 9057, + 7, 4, 0, 0, 9057, 9058, 7, 17, 0, 0, 9058, 9059, 7, 11, 0, 0, 9059, 9060, + 7, 9, 0, 0, 9060, 9061, 7, 3, 0, 0, 9061, 1142, 1, 0, 0, 0, 9062, 9063, + 7, 4, 0, 0, 9063, 9064, 7, 5, 0, 0, 9064, 9065, 7, 9, 0, 0, 9065, 9066, + 7, 3, 0, 0, 9066, 1144, 1, 0, 0, 0, 9067, 9068, 7, 4, 0, 0, 9068, 9069, + 7, 5, 0, 0, 9069, 9070, 7, 9, 0, 0, 9070, 9071, 7, 3, 0, 0, 9071, 9072, + 7, 3, 0, 0, 9072, 9073, 7, 6, 0, 0, 9073, 9074, 7, 1, 0, 0, 9074, 9075, + 7, 9, 0, 0, 9075, 1146, 1, 0, 0, 0, 9076, 9077, 7, 4, 0, 0, 9077, 9078, + 7, 5, 0, 0, 9078, 9079, 7, 9, 0, 0, 9079, 9080, 7, 3, 0, 0, 9080, 9081, + 7, 13, 0, 0, 9081, 9082, 7, 3, 0, 0, 9082, 9083, 7, 6, 0, 0, 9083, 9084, + 7, 11, 0, 0, 9084, 9085, 7, 9, 0, 0, 9085, 1148, 1, 0, 0, 0, 9086, 9087, + 7, 4, 0, 0, 9087, 9088, 7, 13, 0, 0, 9088, 9089, 7, 8, 0, 0, 9089, 9090, + 7, 9, 0, 0, 9090, 9091, 7, 3, 0, 0, 9091, 1150, 1, 0, 0, 0, 9092, 9093, + 7, 4, 0, 0, 9093, 9094, 7, 13, 0, 0, 9094, 9095, 7, 8, 0, 0, 9095, 9096, + 7, 9, 0, 0, 9096, 9097, 7, 3, 0, 0, 9097, 9098, 7, 7, 0, 0, 9098, 9099, + 7, 15, 0, 0, 9099, 9100, 7, 6, 0, 0, 9100, 9101, 7, 2, 0, 0, 9101, 1152, + 1, 0, 0, 0, 9102, 9103, 7, 2, 0, 0, 9103, 9104, 7, 0, 0, 0, 9104, 9105, + 7, 21, 0, 0, 9105, 9106, 7, 9, 0, 0, 9106, 1154, 1, 0, 0, 0, 9107, 9108, + 7, 2, 0, 0, 9108, 9109, 7, 0, 0, 0, 9109, 9110, 7, 3, 0, 0, 9110, 9111, + 7, 0, 0, 0, 9111, 9112, 7, 20, 0, 0, 9112, 9113, 7, 20, 0, 0, 9113, 9114, + 7, 9, 0, 0, 9114, 9115, 7, 20, 0, 0, 9115, 1156, 1, 0, 0, 0, 9116, 9117, + 7, 2, 0, 0, 9117, 9118, 7, 0, 0, 0, 9118, 9119, 7, 3, 0, 0, 9119, 9120, + 7, 0, 0, 0, 9120, 9121, 7, 19, 0, 0, 9121, 9122, 7, 9, 0, 0, 9122, 9123, + 7, 11, 0, 0, 9123, 9124, 7, 9, 0, 0, 9124, 9125, 7, 3, 0, 0, 9125, 9126, + 7, 7, 0, 0, 9126, 1158, 1, 0, 0, 0, 9127, 9128, 7, 2, 0, 0, 9128, 9129, + 7, 0, 0, 0, 9129, 9130, 7, 3, 0, 0, 9130, 9131, 7, 0, 0, 0, 9131, 9132, + 7, 19, 0, 0, 9132, 9133, 5, 95, 0, 0, 9133, 9134, 7, 8, 0, 0, 9134, 9135, + 7, 4, 0, 0, 9135, 9136, 7, 1, 0, 0, 9136, 9137, 7, 9, 0, 0, 9137, 1160, + 1, 0, 0, 0, 9138, 9139, 7, 2, 0, 0, 9139, 9140, 7, 0, 0, 0, 9140, 9141, + 7, 3, 0, 0, 9141, 9142, 7, 16, 0, 0, 9142, 9143, 7, 17, 0, 0, 9143, 9144, + 7, 9, 0, 0, 9144, 9145, 7, 11, 0, 0, 9145, 1162, 1, 0, 0, 0, 9146, 9147, + 5, 39, 0, 0, 9147, 9148, 7, 2, 0, 0, 9148, 9149, 7, 0, 0, 0, 9149, 9150, + 7, 3, 0, 0, 9150, 9151, 7, 16, 0, 0, 9151, 9152, 7, 17, 0, 0, 9152, 9153, + 7, 9, 0, 0, 9153, 9154, 7, 11, 0, 0, 9154, 9155, 5, 39, 0, 0, 9155, 1164, + 1, 0, 0, 0, 9156, 9157, 7, 2, 0, 0, 9157, 9158, 7, 0, 0, 0, 9158, 9159, + 7, 3, 0, 0, 9159, 9160, 7, 11, 0, 0, 9160, 9161, 7, 6, 0, 0, 9161, 9162, + 7, 0, 0, 0, 9162, 9163, 7, 20, 0, 0, 9163, 1166, 1, 0, 0, 0, 9164, 9165, + 7, 2, 0, 0, 9165, 9166, 7, 0, 0, 0, 9166, 9167, 7, 3, 0, 0, 9167, 9168, + 7, 11, 0, 0, 9168, 9169, 7, 6, 0, 0, 9169, 9170, 7, 11, 0, 0, 9170, 9171, + 7, 6, 0, 0, 9171, 9172, 7, 4, 0, 0, 9172, 9173, 7, 8, 0, 0, 9173, 1168, + 1, 0, 0, 0, 9174, 9175, 7, 2, 0, 0, 9175, 9176, 7, 0, 0, 0, 9176, 9177, + 7, 3, 0, 0, 9177, 9178, 7, 11, 0, 0, 9178, 9179, 7, 6, 0, 0, 9179, 9180, + 7, 11, 0, 0, 9180, 9181, 7, 6, 0, 0, 9181, 9182, 7, 4, 0, 0, 9182, 9183, + 7, 8, 0, 0, 9183, 9184, 7, 7, 0, 0, 9184, 1170, 1, 0, 0, 0, 9185, 9186, + 7, 2, 0, 0, 9186, 9187, 7, 0, 0, 0, 9187, 9188, 7, 3, 0, 0, 9188, 9189, + 7, 11, 0, 0, 9189, 9190, 7, 6, 0, 0, 9190, 9191, 7, 11, 0, 0, 9191, 9192, + 7, 6, 0, 0, 9192, 9193, 7, 4, 0, 0, 9193, 9194, 7, 8, 0, 0, 9194, 9195, + 5, 95, 0, 0, 9195, 9196, 7, 11, 0, 0, 9196, 9197, 7, 18, 0, 0, 9197, 9198, + 7, 2, 0, 0, 9198, 9199, 7, 9, 0, 0, 9199, 1172, 1, 0, 0, 0, 9200, 9201, + 7, 2, 0, 0, 9201, 9202, 7, 0, 0, 0, 9202, 9203, 7, 7, 0, 0, 9203, 9204, + 7, 7, 0, 0, 9204, 9205, 7, 13, 0, 0, 9205, 9206, 7, 4, 0, 0, 9206, 9207, + 7, 3, 0, 0, 9207, 9208, 7, 1, 0, 0, 9208, 1174, 1, 0, 0, 0, 9209, 9210, + 7, 2, 0, 0, 9210, 9211, 7, 0, 0, 0, 9211, 9212, 7, 7, 0, 0, 9212, 9213, + 7, 11, 0, 0, 9213, 1176, 1, 0, 0, 0, 9214, 9215, 7, 2, 0, 0, 9215, 9216, + 7, 0, 0, 0, 9216, 9217, 7, 11, 0, 0, 9217, 9218, 7, 15, 0, 0, 9218, 1178, + 1, 0, 0, 0, 9219, 9220, 7, 2, 0, 0, 9220, 9221, 7, 0, 0, 0, 9221, 9222, + 7, 11, 0, 0, 9222, 9223, 7, 11, 0, 0, 9223, 9224, 7, 9, 0, 0, 9224, 9225, + 7, 3, 0, 0, 9225, 9226, 7, 8, 0, 0, 9226, 1180, 1, 0, 0, 0, 9227, 9228, + 7, 2, 0, 0, 9228, 9229, 7, 9, 0, 0, 9229, 9230, 7, 3, 0, 0, 9230, 1182, + 1, 0, 0, 0, 9231, 9232, 7, 2, 0, 0, 9232, 9233, 7, 9, 0, 0, 9233, 9234, + 7, 3, 0, 0, 9234, 9235, 7, 14, 0, 0, 9235, 9236, 7, 9, 0, 0, 9236, 9237, + 7, 8, 0, 0, 9237, 9238, 7, 11, 0, 0, 9238, 1184, 1, 0, 0, 0, 9239, 9240, + 7, 2, 0, 0, 9240, 9241, 7, 9, 0, 0, 9241, 9242, 7, 3, 0, 0, 9242, 9243, + 7, 14, 0, 0, 9243, 9244, 7, 9, 0, 0, 9244, 9245, 7, 8, 0, 0, 9245, 9246, + 7, 11, 0, 0, 9246, 9247, 7, 6, 0, 0, 9247, 9248, 7, 20, 0, 0, 9248, 9249, + 7, 9, 0, 0, 9249, 9250, 5, 95, 0, 0, 9250, 9251, 7, 14, 0, 0, 9251, 9252, + 7, 4, 0, 0, 9252, 9253, 7, 8, 0, 0, 9253, 9254, 7, 11, 0, 0, 9254, 1186, + 1, 0, 0, 0, 9255, 9256, 7, 2, 0, 0, 9256, 9257, 7, 9, 0, 0, 9257, 9258, + 7, 3, 0, 0, 9258, 9259, 7, 14, 0, 0, 9259, 9260, 7, 9, 0, 0, 9260, 9261, + 7, 8, 0, 0, 9261, 9262, 7, 11, 0, 0, 9262, 9263, 7, 6, 0, 0, 9263, 9264, + 7, 20, 0, 0, 9264, 9265, 7, 9, 0, 0, 9265, 9266, 5, 95, 0, 0, 9266, 9267, + 7, 1, 0, 0, 9267, 9268, 7, 6, 0, 0, 9268, 9269, 7, 7, 0, 0, 9269, 9270, + 7, 14, 0, 0, 9270, 1188, 1, 0, 0, 0, 9271, 9272, 7, 2, 0, 0, 9272, 9273, + 7, 9, 0, 0, 9273, 9274, 7, 3, 0, 0, 9274, 9275, 7, 14, 0, 0, 9275, 9276, + 7, 9, 0, 0, 9276, 9277, 7, 8, 0, 0, 9277, 9278, 7, 11, 0, 0, 9278, 9279, + 5, 95, 0, 0, 9279, 9280, 7, 3, 0, 0, 9280, 9281, 7, 0, 0, 0, 9281, 9282, + 7, 8, 0, 0, 9282, 9283, 7, 22, 0, 0, 9283, 1190, 1, 0, 0, 0, 9284, 9285, + 7, 2, 0, 0, 9285, 9286, 7, 9, 0, 0, 9286, 9287, 7, 3, 0, 0, 9287, 9288, + 7, 6, 0, 0, 9288, 9289, 7, 4, 0, 0, 9289, 9290, 7, 1, 0, 0, 9290, 9291, + 7, 6, 0, 0, 9291, 9292, 7, 14, 0, 0, 9292, 9293, 5, 95, 0, 0, 9293, 9294, + 7, 1, 0, 0, 9294, 9295, 7, 0, 0, 0, 9295, 9296, 7, 11, 0, 0, 9296, 9297, + 7, 0, 0, 0, 9297, 9298, 5, 95, 0, 0, 9298, 9299, 7, 3, 0, 0, 9299, 9300, + 7, 9, 0, 0, 9300, 9301, 7, 22, 0, 0, 9301, 9302, 7, 9, 0, 0, 9302, 9303, + 7, 18, 0, 0, 9303, 9304, 7, 6, 0, 0, 9304, 9305, 7, 8, 0, 0, 9305, 9306, + 7, 21, 0, 0, 9306, 1192, 1, 0, 0, 0, 9307, 9308, 7, 2, 0, 0, 9308, 9309, + 7, 9, 0, 0, 9309, 9310, 7, 3, 0, 0, 9310, 9311, 7, 19, 0, 0, 9311, 9312, + 7, 6, 0, 0, 9312, 9313, 7, 7, 0, 0, 9313, 9314, 7, 7, 0, 0, 9314, 9315, + 7, 6, 0, 0, 9315, 9316, 7, 4, 0, 0, 9316, 9317, 7, 8, 0, 0, 9317, 9318, + 5, 95, 0, 0, 9318, 9319, 7, 7, 0, 0, 9319, 9320, 7, 9, 0, 0, 9320, 9321, + 7, 11, 0, 0, 9321, 1194, 1, 0, 0, 0, 9322, 9323, 7, 2, 0, 0, 9323, 9324, + 7, 9, 0, 0, 9324, 9325, 7, 3, 0, 0, 9325, 9326, 7, 7, 0, 0, 9326, 9327, + 7, 6, 0, 0, 9327, 9328, 7, 7, 0, 0, 9328, 9329, 7, 11, 0, 0, 9329, 9330, + 7, 9, 0, 0, 9330, 9331, 7, 1, 0, 0, 9331, 1196, 1, 0, 0, 0, 9332, 9333, + 7, 2, 0, 0, 9333, 9334, 7, 9, 0, 0, 9334, 9335, 7, 3, 0, 0, 9335, 9336, + 7, 7, 0, 0, 9336, 9337, 7, 6, 0, 0, 9337, 9338, 7, 7, 0, 0, 9338, 9339, + 7, 11, 0, 0, 9339, 9340, 5, 95, 0, 0, 9340, 9341, 7, 7, 0, 0, 9341, 9342, + 7, 0, 0, 0, 9342, 9343, 7, 19, 0, 0, 9343, 9344, 7, 2, 0, 0, 9344, 9345, + 7, 20, 0, 0, 9345, 9346, 7, 9, 0, 0, 9346, 9347, 5, 95, 0, 0, 9347, 9348, + 7, 2, 0, 0, 9348, 9349, 7, 9, 0, 0, 9349, 9350, 7, 3, 0, 0, 9350, 9351, + 7, 14, 0, 0, 9351, 9352, 7, 9, 0, 0, 9352, 9353, 7, 8, 0, 0, 9353, 9354, + 7, 11, 0, 0, 9354, 1198, 1, 0, 0, 0, 9355, 9356, 7, 2, 0, 0, 9356, 9357, + 7, 6, 0, 0, 9357, 9358, 7, 8, 0, 0, 9358, 9359, 7, 21, 0, 0, 9359, 9360, + 5, 95, 0, 0, 9360, 9361, 7, 12, 0, 0, 9361, 9362, 7, 9, 0, 0, 9362, 9363, + 7, 1, 0, 0, 9363, 9364, 7, 9, 0, 0, 9364, 9365, 7, 3, 0, 0, 9365, 9366, + 7, 0, 0, 0, 9366, 9367, 7, 11, 0, 0, 9367, 9368, 7, 9, 0, 0, 9368, 1200, + 1, 0, 0, 0, 9369, 9370, 7, 2, 0, 0, 9370, 9371, 7, 6, 0, 0, 9371, 9372, + 7, 2, 0, 0, 9372, 9373, 7, 9, 0, 0, 9373, 1202, 1, 0, 0, 0, 9374, 9375, + 7, 2, 0, 0, 9375, 9376, 7, 6, 0, 0, 9376, 9377, 7, 2, 0, 0, 9377, 9378, + 7, 9, 0, 0, 9378, 9379, 7, 7, 0, 0, 9379, 1204, 1, 0, 0, 0, 9380, 9381, + 7, 2, 0, 0, 9381, 9382, 7, 6, 0, 0, 9382, 9383, 7, 2, 0, 0, 9383, 9384, + 7, 9, 0, 0, 9384, 9385, 5, 95, 0, 0, 9385, 9386, 7, 9, 0, 0, 9386, 9387, + 7, 23, 0, 0, 9387, 9388, 7, 9, 0, 0, 9388, 9389, 7, 14, 0, 0, 9389, 9390, + 7, 17, 0, 0, 9390, 9391, 7, 11, 0, 0, 9391, 9392, 7, 6, 0, 0, 9392, 9393, + 7, 4, 0, 0, 9393, 9394, 7, 8, 0, 0, 9394, 9395, 5, 95, 0, 0, 9395, 9396, + 7, 2, 0, 0, 9396, 9397, 7, 0, 0, 0, 9397, 9398, 7, 17, 0, 0, 9398, 9399, + 7, 7, 0, 0, 9399, 9400, 7, 9, 0, 0, 9400, 9401, 7, 1, 0, 0, 9401, 1206, + 1, 0, 0, 0, 9402, 9403, 7, 2, 0, 0, 9403, 9404, 7, 6, 0, 0, 9404, 9405, + 7, 5, 0, 0, 9405, 9406, 7, 4, 0, 0, 9406, 9407, 7, 11, 0, 0, 9407, 1208, + 1, 0, 0, 0, 9408, 9409, 7, 2, 0, 0, 9409, 9410, 7, 20, 0, 0, 9410, 9411, + 7, 0, 0, 0, 9411, 9412, 7, 8, 0, 0, 9412, 1210, 1, 0, 0, 0, 9413, 9414, + 7, 2, 0, 0, 9414, 9415, 7, 20, 0, 0, 9415, 9416, 7, 0, 0, 0, 9416, 9417, + 7, 11, 0, 0, 9417, 9418, 7, 12, 0, 0, 9418, 9419, 7, 4, 0, 0, 9419, 9420, + 7, 3, 0, 0, 9420, 9421, 7, 19, 0, 0, 9421, 1212, 1, 0, 0, 0, 9422, 9423, + 7, 2, 0, 0, 9423, 9424, 7, 4, 0, 0, 9424, 9425, 7, 20, 0, 0, 9425, 9426, + 7, 6, 0, 0, 9426, 9427, 7, 14, 0, 0, 9427, 9428, 7, 6, 0, 0, 9428, 9429, + 7, 9, 0, 0, 9429, 9430, 7, 7, 0, 0, 9430, 1214, 1, 0, 0, 0, 9431, 9432, + 7, 2, 0, 0, 9432, 9433, 7, 4, 0, 0, 9433, 9434, 7, 20, 0, 0, 9434, 9435, + 7, 6, 0, 0, 9435, 9436, 7, 14, 0, 0, 9436, 9437, 7, 18, 0, 0, 9437, 1216, + 1, 0, 0, 0, 9438, 9439, 7, 2, 0, 0, 9439, 9440, 7, 4, 0, 0, 9440, 9441, + 7, 4, 0, 0, 9441, 9442, 7, 20, 0, 0, 9442, 1218, 1, 0, 0, 0, 9443, 9444, + 7, 2, 0, 0, 9444, 9445, 7, 4, 0, 0, 9445, 9446, 7, 3, 0, 0, 9446, 9447, + 7, 11, 0, 0, 9447, 1220, 1, 0, 0, 0, 9448, 9449, 7, 2, 0, 0, 9449, 9450, + 7, 3, 0, 0, 9450, 9451, 7, 9, 0, 0, 9451, 9452, 7, 14, 0, 0, 9452, 9453, + 7, 9, 0, 0, 9453, 9454, 7, 1, 0, 0, 9454, 9455, 7, 6, 0, 0, 9455, 9456, + 7, 8, 0, 0, 9456, 9457, 7, 21, 0, 0, 9457, 1222, 1, 0, 0, 0, 9458, 9459, + 7, 2, 0, 0, 9459, 9460, 7, 3, 0, 0, 9460, 9461, 7, 9, 0, 0, 9461, 9462, + 7, 14, 0, 0, 9462, 9463, 7, 6, 0, 0, 9463, 9464, 7, 7, 0, 0, 9464, 9465, + 7, 6, 0, 0, 9465, 9466, 7, 4, 0, 0, 9466, 9467, 7, 8, 0, 0, 9467, 1224, + 1, 0, 0, 0, 9468, 9469, 7, 2, 0, 0, 9469, 9470, 7, 3, 0, 0, 9470, 9471, + 7, 9, 0, 0, 9471, 9472, 7, 1, 0, 0, 9472, 9473, 7, 6, 0, 0, 9473, 9474, + 7, 14, 0, 0, 9474, 9475, 7, 0, 0, 0, 9475, 9476, 7, 11, 0, 0, 9476, 9477, + 7, 9, 0, 0, 9477, 1226, 1, 0, 0, 0, 9478, 9479, 7, 2, 0, 0, 9479, 9480, + 7, 3, 0, 0, 9480, 9481, 7, 9, 0, 0, 9481, 9482, 7, 12, 0, 0, 9482, 9483, + 7, 6, 0, 0, 9483, 9484, 7, 23, 0, 0, 9484, 1228, 1, 0, 0, 0, 9485, 9486, + 7, 2, 0, 0, 9486, 9487, 7, 3, 0, 0, 9487, 9488, 7, 9, 0, 0, 9488, 9489, + 7, 7, 0, 0, 9489, 9490, 7, 9, 0, 0, 9490, 9491, 7, 3, 0, 0, 9491, 9492, + 7, 5, 0, 0, 9492, 9493, 7, 9, 0, 0, 9493, 9494, 5, 95, 0, 0, 9494, 9495, + 7, 7, 0, 0, 9495, 9496, 7, 2, 0, 0, 9496, 9497, 7, 0, 0, 0, 9497, 9498, + 7, 14, 0, 0, 9498, 9499, 7, 9, 0, 0, 9499, 1230, 1, 0, 0, 0, 9500, 9501, + 7, 2, 0, 0, 9501, 9502, 7, 3, 0, 0, 9502, 9503, 7, 9, 0, 0, 9503, 9504, + 7, 5, 0, 0, 9504, 9505, 7, 9, 0, 0, 9505, 9506, 7, 8, 0, 0, 9506, 9507, + 7, 11, 0, 0, 9507, 9508, 5, 95, 0, 0, 9508, 9509, 7, 17, 0, 0, 9509, 9510, + 7, 8, 0, 0, 9510, 9511, 7, 20, 0, 0, 9511, 9512, 7, 4, 0, 0, 9512, 9513, + 7, 0, 0, 0, 9513, 9514, 7, 1, 0, 0, 9514, 9515, 5, 95, 0, 0, 9515, 9516, + 7, 11, 0, 0, 9516, 9517, 7, 4, 0, 0, 9517, 9518, 5, 95, 0, 0, 9518, 9519, + 7, 6, 0, 0, 9519, 9520, 7, 8, 0, 0, 9520, 9521, 7, 20, 0, 0, 9521, 9522, + 7, 6, 0, 0, 9522, 9523, 7, 8, 0, 0, 9523, 9524, 7, 9, 0, 0, 9524, 9525, + 5, 95, 0, 0, 9525, 9526, 7, 17, 0, 0, 9526, 9527, 7, 3, 0, 0, 9527, 9528, + 7, 20, 0, 0, 9528, 1232, 1, 0, 0, 0, 9529, 9530, 7, 2, 0, 0, 9530, 9531, + 7, 3, 0, 0, 9531, 9532, 7, 9, 0, 0, 9532, 9533, 7, 5, 0, 0, 9533, 9534, + 7, 9, 0, 0, 9534, 9535, 7, 8, 0, 0, 9535, 9536, 7, 11, 0, 0, 9536, 9537, + 5, 95, 0, 0, 9537, 9538, 7, 17, 0, 0, 9538, 9539, 7, 8, 0, 0, 9539, 9540, + 7, 20, 0, 0, 9540, 9541, 7, 4, 0, 0, 9541, 9542, 7, 0, 0, 0, 9542, 9543, + 7, 1, 0, 0, 9543, 9544, 5, 95, 0, 0, 9544, 9545, 7, 11, 0, 0, 9545, 9546, + 7, 4, 0, 0, 9546, 9547, 5, 95, 0, 0, 9547, 9548, 7, 6, 0, 0, 9548, 9549, + 7, 8, 0, 0, 9549, 9550, 7, 11, 0, 0, 9550, 9551, 7, 9, 0, 0, 9551, 9552, + 7, 3, 0, 0, 9552, 9553, 7, 8, 0, 0, 9553, 9554, 7, 0, 0, 0, 9554, 9555, + 7, 20, 0, 0, 9555, 9556, 5, 95, 0, 0, 9556, 9557, 7, 7, 0, 0, 9557, 9558, + 7, 11, 0, 0, 9558, 9559, 7, 0, 0, 0, 9559, 9560, 7, 21, 0, 0, 9560, 9561, + 7, 9, 0, 0, 9561, 9562, 7, 7, 0, 0, 9562, 1234, 1, 0, 0, 0, 9563, 9564, + 7, 2, 0, 0, 9564, 9565, 7, 3, 0, 0, 9565, 9566, 7, 9, 0, 0, 9566, 9567, + 5, 95, 0, 0, 9567, 9568, 7, 0, 0, 0, 9568, 9569, 7, 17, 0, 0, 9569, 9570, + 7, 11, 0, 0, 9570, 9571, 7, 15, 0, 0, 9571, 9572, 7, 4, 0, 0, 9572, 9573, + 7, 3, 0, 0, 9573, 9574, 7, 6, 0, 0, 9574, 9575, 7, 24, 0, 0, 9575, 9576, + 7, 9, 0, 0, 9576, 9577, 7, 1, 0, 0, 9577, 9578, 5, 95, 0, 0, 9578, 9579, + 7, 3, 0, 0, 9579, 9580, 7, 4, 0, 0, 9580, 9581, 7, 20, 0, 0, 9581, 9582, + 7, 9, 0, 0, 9582, 9583, 7, 7, 0, 0, 9583, 9584, 5, 95, 0, 0, 9584, 9585, + 7, 20, 0, 0, 9585, 9586, 7, 6, 0, 0, 9586, 9587, 7, 7, 0, 0, 9587, 9588, + 7, 11, 0, 0, 9588, 1236, 1, 0, 0, 0, 9589, 9590, 7, 2, 0, 0, 9590, 9591, + 7, 3, 0, 0, 9591, 9592, 7, 6, 0, 0, 9592, 9593, 7, 19, 0, 0, 9593, 9594, + 7, 0, 0, 0, 9594, 9595, 7, 3, 0, 0, 9595, 9596, 7, 18, 0, 0, 9596, 1238, + 1, 0, 0, 0, 9597, 9598, 7, 2, 0, 0, 9598, 9599, 7, 3, 0, 0, 9599, 9600, + 7, 6, 0, 0, 9600, 9601, 7, 19, 0, 0, 9601, 9602, 7, 0, 0, 0, 9602, 9603, + 7, 3, 0, 0, 9603, 9604, 7, 18, 0, 0, 9604, 9605, 5, 95, 0, 0, 9605, 9606, + 7, 3, 0, 0, 9606, 9607, 7, 4, 0, 0, 9607, 9608, 7, 20, 0, 0, 9608, 9609, + 7, 9, 0, 0, 9609, 1240, 1, 0, 0, 0, 9610, 9611, 7, 2, 0, 0, 9611, 9612, + 7, 3, 0, 0, 9612, 9613, 7, 6, 0, 0, 9613, 9614, 7, 4, 0, 0, 9614, 9615, + 7, 3, 0, 0, 9615, 1242, 1, 0, 0, 0, 9616, 9617, 7, 2, 0, 0, 9617, 9618, + 7, 3, 0, 0, 9618, 9619, 7, 6, 0, 0, 9619, 9620, 7, 4, 0, 0, 9620, 9621, + 7, 3, 0, 0, 9621, 9622, 7, 6, 0, 0, 9622, 9623, 7, 11, 0, 0, 9623, 9624, + 7, 18, 0, 0, 9624, 1244, 1, 0, 0, 0, 9625, 9626, 7, 2, 0, 0, 9626, 9627, + 7, 3, 0, 0, 9627, 9628, 7, 6, 0, 0, 9628, 9629, 7, 4, 0, 0, 9629, 9630, + 7, 3, 0, 0, 9630, 9631, 7, 6, 0, 0, 9631, 9632, 7, 11, 0, 0, 9632, 9633, + 7, 18, 0, 0, 9633, 9634, 5, 95, 0, 0, 9634, 9635, 7, 20, 0, 0, 9635, 9636, + 7, 9, 0, 0, 9636, 9637, 7, 5, 0, 0, 9637, 9638, 7, 9, 0, 0, 9638, 9639, + 7, 20, 0, 0, 9639, 1246, 1, 0, 0, 0, 9640, 9641, 7, 2, 0, 0, 9641, 9642, + 7, 3, 0, 0, 9642, 9643, 7, 6, 0, 0, 9643, 9644, 7, 5, 0, 0, 9644, 9645, + 7, 0, 0, 0, 9645, 9646, 7, 11, 0, 0, 9646, 9647, 7, 9, 0, 0, 9647, 1248, + 1, 0, 0, 0, 9648, 9649, 7, 2, 0, 0, 9649, 9650, 7, 3, 0, 0, 9650, 9651, + 7, 6, 0, 0, 9651, 9652, 7, 5, 0, 0, 9652, 9653, 7, 0, 0, 0, 9653, 9654, + 7, 11, 0, 0, 9654, 9655, 7, 9, 0, 0, 9655, 9656, 5, 95, 0, 0, 9656, 9657, + 7, 22, 0, 0, 9657, 9658, 7, 9, 0, 0, 9658, 9659, 7, 18, 0, 0, 9659, 1250, + 1, 0, 0, 0, 9660, 9661, 7, 2, 0, 0, 9661, 9662, 7, 3, 0, 0, 9662, 9663, + 7, 6, 0, 0, 9663, 9664, 7, 5, 0, 0, 9664, 9665, 7, 6, 0, 0, 9665, 9666, + 7, 20, 0, 0, 9666, 9667, 7, 9, 0, 0, 9667, 9668, 7, 21, 0, 0, 9668, 9669, + 7, 9, 0, 0, 9669, 9670, 7, 7, 0, 0, 9670, 1252, 1, 0, 0, 0, 9671, 9672, + 7, 2, 0, 0, 9672, 9673, 7, 3, 0, 0, 9673, 9674, 7, 4, 0, 0, 9674, 9675, + 7, 14, 0, 0, 9675, 1254, 1, 0, 0, 0, 9676, 9677, 7, 2, 0, 0, 9677, 9678, + 7, 3, 0, 0, 9678, 9679, 7, 4, 0, 0, 9679, 9680, 7, 14, 0, 0, 9680, 9681, + 7, 9, 0, 0, 9681, 9682, 7, 1, 0, 0, 9682, 9683, 7, 17, 0, 0, 9683, 9684, + 7, 3, 0, 0, 9684, 9685, 7, 9, 0, 0, 9685, 1256, 1, 0, 0, 0, 9686, 9687, + 7, 2, 0, 0, 9687, 9688, 7, 3, 0, 0, 9688, 9689, 7, 4, 0, 0, 9689, 9690, + 7, 14, 0, 0, 9690, 9691, 7, 9, 0, 0, 9691, 9692, 7, 1, 0, 0, 9692, 9693, + 7, 17, 0, 0, 9693, 9694, 7, 3, 0, 0, 9694, 9695, 7, 9, 0, 0, 9695, 9696, + 7, 7, 0, 0, 9696, 1258, 1, 0, 0, 0, 9697, 9698, 7, 2, 0, 0, 9698, 9699, + 7, 3, 0, 0, 9699, 9700, 7, 4, 0, 0, 9700, 9701, 7, 14, 0, 0, 9701, 9702, + 7, 9, 0, 0, 9702, 9703, 7, 1, 0, 0, 9703, 9704, 7, 17, 0, 0, 9704, 9705, + 7, 3, 0, 0, 9705, 9706, 7, 9, 0, 0, 9706, 9707, 5, 95, 0, 0, 9707, 9708, + 7, 8, 0, 0, 9708, 9709, 7, 0, 0, 0, 9709, 9710, 7, 19, 0, 0, 9710, 9711, + 7, 9, 0, 0, 9711, 1260, 1, 0, 0, 0, 9712, 9713, 7, 2, 0, 0, 9713, 9714, + 7, 3, 0, 0, 9714, 9715, 7, 4, 0, 0, 9715, 9716, 7, 14, 0, 0, 9716, 9717, + 7, 9, 0, 0, 9717, 9718, 7, 7, 0, 0, 9718, 9719, 7, 7, 0, 0, 9719, 1262, + 1, 0, 0, 0, 9720, 9721, 7, 2, 0, 0, 9721, 9722, 7, 3, 0, 0, 9722, 9723, + 7, 4, 0, 0, 9723, 9724, 7, 12, 0, 0, 9724, 9725, 7, 6, 0, 0, 9725, 9726, + 7, 20, 0, 0, 9726, 9727, 7, 9, 0, 0, 9727, 1264, 1, 0, 0, 0, 9728, 9729, + 7, 2, 0, 0, 9729, 9730, 7, 3, 0, 0, 9730, 9731, 7, 4, 0, 0, 9731, 9732, + 7, 2, 0, 0, 9732, 9733, 7, 9, 0, 0, 9733, 9734, 7, 3, 0, 0, 9734, 9735, + 7, 11, 0, 0, 9735, 9736, 7, 18, 0, 0, 9736, 1266, 1, 0, 0, 0, 9737, 9738, + 7, 2, 0, 0, 9738, 9739, 7, 3, 0, 0, 9739, 9740, 7, 4, 0, 0, 9740, 9741, + 7, 5, 0, 0, 9741, 9742, 7, 6, 0, 0, 9742, 9743, 7, 1, 0, 0, 9743, 9744, + 7, 9, 0, 0, 9744, 9745, 7, 3, 0, 0, 9745, 1268, 1, 0, 0, 0, 9746, 9747, + 7, 2, 0, 0, 9747, 9748, 7, 3, 0, 0, 9748, 9749, 7, 4, 0, 0, 9749, 9750, + 7, 5, 0, 0, 9750, 9751, 7, 6, 0, 0, 9751, 9752, 7, 1, 0, 0, 9752, 9753, + 7, 9, 0, 0, 9753, 9754, 7, 3, 0, 0, 9754, 9755, 5, 95, 0, 0, 9755, 9756, + 7, 22, 0, 0, 9756, 9757, 7, 9, 0, 0, 9757, 9758, 7, 18, 0, 0, 9758, 9759, + 5, 95, 0, 0, 9759, 9760, 7, 8, 0, 0, 9760, 9761, 7, 0, 0, 0, 9761, 9762, + 7, 19, 0, 0, 9762, 9763, 7, 9, 0, 0, 9763, 1270, 1, 0, 0, 0, 9764, 9765, + 7, 2, 0, 0, 9765, 9766, 7, 17, 0, 0, 9766, 9767, 7, 10, 0, 0, 9767, 9768, + 7, 20, 0, 0, 9768, 9769, 7, 6, 0, 0, 9769, 9770, 7, 14, 0, 0, 9770, 1272, + 1, 0, 0, 0, 9771, 9772, 7, 2, 0, 0, 9772, 9773, 7, 17, 0, 0, 9773, 9774, + 7, 3, 0, 0, 9774, 9775, 7, 21, 0, 0, 9775, 9776, 7, 9, 0, 0, 9776, 1274, + 1, 0, 0, 0, 9777, 9778, 7, 2, 0, 0, 9778, 9779, 7, 17, 0, 0, 9779, 9780, + 7, 11, 0, 0, 9780, 1276, 1, 0, 0, 0, 9781, 9782, 7, 2, 0, 0, 9782, 9783, + 7, 18, 0, 0, 9783, 9784, 7, 11, 0, 0, 9784, 9785, 7, 15, 0, 0, 9785, 9786, + 7, 4, 0, 0, 9786, 9787, 7, 8, 0, 0, 9787, 1278, 1, 0, 0, 0, 9788, 9789, + 7, 16, 0, 0, 9789, 9790, 7, 17, 0, 0, 9790, 9791, 7, 0, 0, 0, 9791, 9792, + 7, 20, 0, 0, 9792, 9793, 7, 6, 0, 0, 9793, 9794, 7, 12, 0, 0, 9794, 9795, + 7, 18, 0, 0, 9795, 1280, 1, 0, 0, 0, 9796, 9797, 7, 16, 0, 0, 9797, 9798, + 7, 17, 0, 0, 9798, 9799, 7, 9, 0, 0, 9799, 9800, 7, 3, 0, 0, 9800, 9801, + 7, 6, 0, 0, 9801, 9802, 7, 9, 0, 0, 9802, 9803, 7, 7, 0, 0, 9803, 1282, + 1, 0, 0, 0, 9804, 9805, 7, 16, 0, 0, 9805, 9806, 7, 17, 0, 0, 9806, 9807, + 7, 9, 0, 0, 9807, 9808, 7, 3, 0, 0, 9808, 9809, 7, 18, 0, 0, 9809, 1284, + 1, 0, 0, 0, 9810, 9811, 7, 16, 0, 0, 9811, 9812, 7, 17, 0, 0, 9812, 9813, + 7, 9, 0, 0, 9813, 9814, 7, 3, 0, 0, 9814, 9815, 7, 18, 0, 0, 9815, 9816, + 5, 95, 0, 0, 9816, 9817, 7, 0, 0, 0, 9817, 9818, 7, 14, 0, 0, 9818, 9819, + 7, 14, 0, 0, 9819, 9820, 7, 9, 0, 0, 9820, 9821, 7, 20, 0, 0, 9821, 9822, + 7, 9, 0, 0, 9822, 9823, 7, 3, 0, 0, 9823, 9824, 7, 0, 0, 0, 9824, 9825, + 7, 11, 0, 0, 9825, 9826, 7, 6, 0, 0, 9826, 9827, 7, 4, 0, 0, 9827, 9828, + 7, 8, 0, 0, 9828, 9829, 5, 95, 0, 0, 9829, 9830, 7, 19, 0, 0, 9830, 9831, + 7, 0, 0, 0, 9831, 9832, 7, 23, 0, 0, 9832, 9833, 5, 95, 0, 0, 9833, 9834, + 7, 7, 0, 0, 9834, 9835, 7, 14, 0, 0, 9835, 9836, 7, 0, 0, 0, 9836, 9837, + 7, 20, 0, 0, 9837, 9838, 7, 9, 0, 0, 9838, 9839, 5, 95, 0, 0, 9839, 9840, + 7, 12, 0, 0, 9840, 9841, 7, 0, 0, 0, 9841, 9842, 7, 14, 0, 0, 9842, 9843, + 7, 11, 0, 0, 9843, 9844, 7, 4, 0, 0, 9844, 9845, 7, 3, 0, 0, 9845, 1286, + 1, 0, 0, 0, 9846, 9847, 7, 16, 0, 0, 9847, 9848, 7, 17, 0, 0, 9848, 9849, + 7, 9, 0, 0, 9849, 9850, 7, 3, 0, 0, 9850, 9851, 7, 18, 0, 0, 9851, 9852, + 5, 95, 0, 0, 9852, 9853, 7, 11, 0, 0, 9853, 9854, 7, 0, 0, 0, 9854, 9855, + 7, 21, 0, 0, 9855, 1288, 1, 0, 0, 0, 9856, 9857, 7, 16, 0, 0, 9857, 9858, + 7, 17, 0, 0, 9858, 9859, 7, 9, 0, 0, 9859, 9860, 7, 17, 0, 0, 9860, 9861, + 7, 9, 0, 0, 9861, 1290, 1, 0, 0, 0, 9862, 9863, 7, 16, 0, 0, 9863, 9864, + 7, 17, 0, 0, 9864, 9865, 7, 4, 0, 0, 9865, 9866, 7, 11, 0, 0, 9866, 9867, + 7, 9, 0, 0, 9867, 9868, 7, 1, 0, 0, 9868, 9869, 5, 95, 0, 0, 9869, 9870, + 7, 6, 0, 0, 9870, 9871, 7, 1, 0, 0, 9871, 9872, 7, 9, 0, 0, 9872, 9873, + 7, 8, 0, 0, 9873, 9874, 7, 11, 0, 0, 9874, 9875, 7, 6, 0, 0, 9875, 9876, + 7, 12, 0, 0, 9876, 9877, 7, 6, 0, 0, 9877, 9878, 7, 9, 0, 0, 9878, 9879, + 7, 3, 0, 0, 9879, 9880, 7, 7, 0, 0, 9880, 9881, 5, 95, 0, 0, 9881, 9882, + 7, 6, 0, 0, 9882, 9883, 7, 21, 0, 0, 9883, 9884, 7, 8, 0, 0, 9884, 9885, + 7, 4, 0, 0, 9885, 9886, 7, 3, 0, 0, 9886, 9887, 7, 9, 0, 0, 9887, 9888, + 5, 95, 0, 0, 9888, 9889, 7, 14, 0, 0, 9889, 9890, 7, 0, 0, 0, 9890, 9891, + 7, 7, 0, 0, 9891, 9892, 7, 9, 0, 0, 9892, 1292, 1, 0, 0, 0, 9893, 9894, + 7, 3, 0, 0, 9894, 9895, 7, 0, 0, 0, 9895, 9896, 7, 8, 0, 0, 9896, 9897, + 7, 21, 0, 0, 9897, 9898, 7, 9, 0, 0, 9898, 1294, 1, 0, 0, 0, 9899, 9900, + 7, 3, 0, 0, 9900, 9901, 7, 0, 0, 0, 9901, 9902, 7, 8, 0, 0, 9902, 9903, + 7, 22, 0, 0, 9903, 1296, 1, 0, 0, 0, 9904, 9905, 7, 3, 0, 0, 9905, 9906, + 7, 0, 0, 0, 9906, 9907, 7, 13, 0, 0, 9907, 9908, 5, 95, 0, 0, 9908, 9909, + 7, 1, 0, 0, 9909, 9910, 7, 9, 0, 0, 9910, 9911, 7, 12, 0, 0, 9911, 9912, + 7, 20, 0, 0, 9912, 9913, 7, 0, 0, 0, 9913, 9914, 7, 11, 0, 0, 9914, 9915, + 7, 9, 0, 0, 9915, 1298, 1, 0, 0, 0, 9916, 9917, 7, 3, 0, 0, 9917, 9918, + 7, 9, 0, 0, 9918, 9919, 7, 0, 0, 0, 9919, 9920, 7, 1, 0, 0, 9920, 1300, + 1, 0, 0, 0, 9921, 9922, 7, 3, 0, 0, 9922, 9923, 7, 9, 0, 0, 9923, 9924, + 7, 0, 0, 0, 9924, 9925, 7, 1, 0, 0, 9925, 9926, 7, 9, 0, 0, 9926, 9927, + 7, 3, 0, 0, 9927, 1302, 1, 0, 0, 0, 9928, 9929, 7, 3, 0, 0, 9929, 9930, + 7, 9, 0, 0, 9930, 9931, 7, 0, 0, 0, 9931, 9932, 7, 1, 0, 0, 9932, 9933, + 7, 4, 0, 0, 9933, 9934, 7, 8, 0, 0, 9934, 9935, 7, 20, 0, 0, 9935, 9936, + 7, 18, 0, 0, 9936, 1304, 1, 0, 0, 0, 9937, 9938, 7, 3, 0, 0, 9938, 9939, + 7, 9, 0, 0, 9939, 9940, 7, 0, 0, 0, 9940, 9941, 7, 1, 0, 0, 9941, 9942, + 7, 2, 0, 0, 9942, 9943, 7, 0, 0, 0, 9943, 9944, 7, 7, 0, 0, 9944, 9945, + 7, 11, 0, 0, 9945, 1306, 1, 0, 0, 0, 9946, 9947, 7, 3, 0, 0, 9947, 9948, + 7, 9, 0, 0, 9948, 9949, 7, 0, 0, 0, 9949, 9950, 7, 1, 0, 0, 9950, 9951, + 7, 11, 0, 0, 9951, 9952, 7, 9, 0, 0, 9952, 9953, 7, 23, 0, 0, 9953, 9954, + 7, 11, 0, 0, 9954, 1308, 1, 0, 0, 0, 9955, 9956, 7, 3, 0, 0, 9956, 9957, + 7, 9, 0, 0, 9957, 9958, 7, 0, 0, 0, 9958, 9959, 7, 1, 0, 0, 9959, 9960, + 7, 13, 0, 0, 9960, 9961, 7, 3, 0, 0, 9961, 9962, 7, 6, 0, 0, 9962, 9963, + 7, 11, 0, 0, 9963, 9964, 7, 9, 0, 0, 9964, 1310, 1, 0, 0, 0, 9965, 9966, + 7, 3, 0, 0, 9966, 9967, 7, 9, 0, 0, 9967, 9968, 7, 0, 0, 0, 9968, 9969, + 7, 1, 0, 0, 9969, 9970, 5, 95, 0, 0, 9970, 9971, 7, 14, 0, 0, 9971, 9972, + 7, 4, 0, 0, 9972, 9973, 7, 19, 0, 0, 9973, 9974, 7, 19, 0, 0, 9974, 9975, + 7, 6, 0, 0, 9975, 9976, 7, 11, 0, 0, 9976, 9977, 7, 11, 0, 0, 9977, 9978, + 7, 9, 0, 0, 9978, 9979, 7, 1, 0, 0, 9979, 9980, 5, 95, 0, 0, 9980, 9981, + 7, 7, 0, 0, 9981, 9982, 7, 8, 0, 0, 9982, 9983, 7, 0, 0, 0, 9983, 9984, + 7, 2, 0, 0, 9984, 9985, 7, 7, 0, 0, 9985, 9986, 7, 15, 0, 0, 9986, 9987, + 7, 4, 0, 0, 9987, 9988, 7, 11, 0, 0, 9988, 1312, 1, 0, 0, 0, 9989, 9990, + 7, 3, 0, 0, 9990, 9991, 7, 9, 0, 0, 9991, 9992, 7, 0, 0, 0, 9992, 9993, + 7, 1, 0, 0, 9993, 9994, 5, 95, 0, 0, 9994, 9995, 7, 4, 0, 0, 9995, 9996, + 7, 8, 0, 0, 9996, 9997, 7, 20, 0, 0, 9997, 9998, 7, 18, 0, 0, 9998, 1314, + 1, 0, 0, 0, 9999, 10000, 7, 3, 0, 0, 10000, 10001, 7, 9, 0, 0, 10001, 10002, + 7, 0, 0, 0, 10002, 10003, 7, 1, 0, 0, 10003, 10004, 5, 95, 0, 0, 10004, + 10005, 7, 4, 0, 0, 10005, 10006, 7, 8, 0, 0, 10006, 10007, 7, 20, 0, 0, + 10007, 10008, 7, 18, 0, 0, 10008, 10009, 5, 95, 0, 0, 10009, 10010, 7, + 3, 0, 0, 10010, 10011, 7, 4, 0, 0, 10011, 10012, 7, 17, 0, 0, 10012, 10013, + 7, 11, 0, 0, 10013, 10014, 7, 6, 0, 0, 10014, 10015, 7, 8, 0, 0, 10015, + 10016, 7, 21, 0, 0, 10016, 10017, 5, 95, 0, 0, 10017, 10018, 7, 20, 0, + 0, 10018, 10019, 7, 6, 0, 0, 10019, 10020, 7, 7, 0, 0, 10020, 10021, 7, + 11, 0, 0, 10021, 1316, 1, 0, 0, 0, 10022, 10023, 7, 3, 0, 0, 10023, 10024, + 7, 9, 0, 0, 10024, 10025, 7, 0, 0, 0, 10025, 10026, 7, 1, 0, 0, 10026, + 10027, 5, 95, 0, 0, 10027, 10028, 7, 13, 0, 0, 10028, 10029, 7, 3, 0, 0, + 10029, 10030, 7, 6, 0, 0, 10030, 10031, 7, 11, 0, 0, 10031, 10032, 7, 9, + 0, 0, 10032, 1318, 1, 0, 0, 0, 10033, 10034, 7, 3, 0, 0, 10034, 10035, + 7, 9, 0, 0, 10035, 10036, 7, 10, 0, 0, 10036, 10037, 7, 17, 0, 0, 10037, + 10038, 7, 6, 0, 0, 10038, 10039, 7, 20, 0, 0, 10039, 10040, 7, 1, 0, 0, + 10040, 1320, 1, 0, 0, 0, 10041, 10042, 7, 3, 0, 0, 10042, 10043, 7, 9, + 0, 0, 10043, 10044, 7, 14, 0, 0, 10044, 10045, 7, 9, 0, 0, 10045, 10046, + 7, 6, 0, 0, 10046, 10047, 7, 5, 0, 0, 10047, 10048, 7, 9, 0, 0, 10048, + 1322, 1, 0, 0, 0, 10049, 10050, 7, 3, 0, 0, 10050, 10051, 7, 9, 0, 0, 10051, + 10052, 7, 14, 0, 0, 10052, 10053, 7, 20, 0, 0, 10053, 10054, 7, 17, 0, + 0, 10054, 10055, 7, 7, 0, 0, 10055, 10056, 7, 11, 0, 0, 10056, 10057, 7, + 9, 0, 0, 10057, 10058, 7, 3, 0, 0, 10058, 1324, 1, 0, 0, 0, 10059, 10060, + 7, 3, 0, 0, 10060, 10061, 7, 9, 0, 0, 10061, 10062, 7, 14, 0, 0, 10062, + 10063, 7, 4, 0, 0, 10063, 10064, 7, 19, 0, 0, 10064, 10065, 7, 2, 0, 0, + 10065, 10066, 7, 6, 0, 0, 10066, 10067, 7, 20, 0, 0, 10067, 10068, 7, 9, + 0, 0, 10068, 1326, 1, 0, 0, 0, 10069, 10070, 7, 3, 0, 0, 10070, 10071, + 7, 9, 0, 0, 10071, 10072, 7, 14, 0, 0, 10072, 10073, 7, 4, 0, 0, 10073, + 10074, 7, 8, 0, 0, 10074, 10075, 7, 12, 0, 0, 10075, 10076, 7, 6, 0, 0, + 10076, 10077, 7, 21, 0, 0, 10077, 10078, 7, 17, 0, 0, 10078, 10079, 7, + 3, 0, 0, 10079, 10080, 7, 9, 0, 0, 10080, 1328, 1, 0, 0, 0, 10081, 10082, + 7, 3, 0, 0, 10082, 10083, 7, 9, 0, 0, 10083, 10084, 7, 14, 0, 0, 10084, + 10085, 7, 4, 0, 0, 10085, 10086, 7, 3, 0, 0, 10086, 10087, 7, 1, 0, 0, + 10087, 10088, 5, 95, 0, 0, 10088, 10089, 7, 1, 0, 0, 10089, 10090, 7, 9, + 0, 0, 10090, 10091, 7, 20, 0, 0, 10091, 10092, 7, 6, 0, 0, 10092, 10093, + 7, 19, 0, 0, 10093, 10094, 7, 6, 0, 0, 10094, 10095, 7, 11, 0, 0, 10095, + 10096, 7, 9, 0, 0, 10096, 10097, 7, 3, 0, 0, 10097, 1330, 1, 0, 0, 0, 10098, + 10099, 7, 3, 0, 0, 10099, 10100, 7, 9, 0, 0, 10100, 10101, 7, 14, 0, 0, + 10101, 10102, 7, 4, 0, 0, 10102, 10103, 7, 5, 0, 0, 10103, 10104, 7, 9, + 0, 0, 10104, 10105, 7, 3, 0, 0, 10105, 10106, 7, 18, 0, 0, 10106, 1332, + 1, 0, 0, 0, 10107, 10108, 7, 3, 0, 0, 10108, 10109, 7, 9, 0, 0, 10109, + 10110, 7, 14, 0, 0, 10110, 10111, 7, 17, 0, 0, 10111, 10112, 7, 3, 0, 0, + 10112, 10113, 7, 7, 0, 0, 10113, 10114, 7, 6, 0, 0, 10114, 10115, 7, 5, + 0, 0, 10115, 10116, 7, 9, 0, 0, 10116, 1334, 1, 0, 0, 0, 10117, 10118, + 7, 3, 0, 0, 10118, 10119, 7, 9, 0, 0, 10119, 10120, 7, 14, 0, 0, 10120, + 10121, 7, 17, 0, 0, 10121, 10122, 7, 3, 0, 0, 10122, 10123, 7, 7, 0, 0, + 10123, 10124, 7, 6, 0, 0, 10124, 10125, 7, 5, 0, 0, 10125, 10126, 7, 9, + 0, 0, 10126, 10127, 5, 95, 0, 0, 10127, 10128, 7, 11, 0, 0, 10128, 10129, + 7, 3, 0, 0, 10129, 10130, 7, 6, 0, 0, 10130, 10131, 7, 21, 0, 0, 10131, + 10132, 7, 21, 0, 0, 10132, 10133, 7, 9, 0, 0, 10133, 10134, 7, 3, 0, 0, + 10134, 10135, 7, 7, 0, 0, 10135, 1336, 1, 0, 0, 0, 10136, 10137, 7, 3, + 0, 0, 10137, 10138, 7, 9, 0, 0, 10138, 10139, 7, 12, 0, 0, 10139, 10140, + 7, 9, 0, 0, 10140, 10141, 7, 3, 0, 0, 10141, 10142, 7, 9, 0, 0, 10142, + 10143, 7, 8, 0, 0, 10143, 10144, 7, 14, 0, 0, 10144, 10145, 7, 9, 0, 0, + 10145, 10146, 7, 7, 0, 0, 10146, 1338, 1, 0, 0, 0, 10147, 10148, 7, 3, + 0, 0, 10148, 10149, 7, 9, 0, 0, 10149, 10150, 7, 12, 0, 0, 10150, 10151, + 7, 9, 0, 0, 10151, 10152, 7, 3, 0, 0, 10152, 10153, 7, 9, 0, 0, 10153, + 10154, 7, 8, 0, 0, 10154, 10155, 7, 14, 0, 0, 10155, 10156, 7, 9, 0, 0, + 10156, 10157, 5, 95, 0, 0, 10157, 10158, 7, 17, 0, 0, 10158, 10159, 7, + 7, 0, 0, 10159, 10160, 7, 0, 0, 0, 10160, 10161, 7, 21, 0, 0, 10161, 10162, + 7, 9, 0, 0, 10162, 1340, 1, 0, 0, 0, 10163, 10164, 7, 3, 0, 0, 10164, 10165, + 7, 9, 0, 0, 10165, 10166, 7, 12, 0, 0, 10166, 10167, 7, 3, 0, 0, 10167, + 10168, 7, 9, 0, 0, 10168, 10169, 7, 7, 0, 0, 10169, 10170, 7, 15, 0, 0, + 10170, 1342, 1, 0, 0, 0, 10171, 10172, 7, 3, 0, 0, 10172, 10173, 7, 9, + 0, 0, 10173, 10174, 7, 12, 0, 0, 10174, 10175, 7, 3, 0, 0, 10175, 10176, + 7, 9, 0, 0, 10176, 10177, 7, 7, 0, 0, 10177, 10178, 7, 15, 0, 0, 10178, + 10179, 5, 95, 0, 0, 10179, 10180, 7, 4, 0, 0, 10180, 10181, 7, 8, 0, 0, + 10181, 10182, 5, 95, 0, 0, 10182, 10183, 7, 14, 0, 0, 10183, 10184, 7, + 3, 0, 0, 10184, 10185, 7, 9, 0, 0, 10185, 10186, 7, 0, 0, 0, 10186, 10187, + 7, 11, 0, 0, 10187, 10188, 7, 9, 0, 0, 10188, 1344, 1, 0, 0, 0, 10189, + 10190, 7, 3, 0, 0, 10190, 10191, 7, 9, 0, 0, 10191, 10192, 7, 21, 0, 0, + 10192, 10193, 7, 6, 0, 0, 10193, 10194, 7, 4, 0, 0, 10194, 10195, 7, 8, + 0, 0, 10195, 1346, 1, 0, 0, 0, 10196, 10197, 7, 3, 0, 0, 10197, 10198, + 7, 9, 0, 0, 10198, 10199, 7, 21, 0, 0, 10199, 10200, 7, 6, 0, 0, 10200, + 10201, 7, 4, 0, 0, 10201, 10202, 7, 8, 0, 0, 10202, 10203, 7, 7, 0, 0, + 10203, 1348, 1, 0, 0, 0, 10204, 10205, 7, 3, 0, 0, 10205, 10206, 7, 9, + 0, 0, 10206, 10207, 7, 21, 0, 0, 10207, 10208, 7, 6, 0, 0, 10208, 10209, + 7, 4, 0, 0, 10209, 10210, 7, 8, 0, 0, 10210, 10211, 5, 95, 0, 0, 10211, + 10212, 7, 21, 0, 0, 10212, 10213, 7, 3, 0, 0, 10213, 10214, 7, 4, 0, 0, + 10214, 10215, 7, 17, 0, 0, 10215, 10216, 7, 2, 0, 0, 10216, 1350, 1, 0, + 0, 0, 10217, 10218, 7, 3, 0, 0, 10218, 10219, 7, 9, 0, 0, 10219, 10220, + 7, 20, 0, 0, 10220, 10221, 7, 0, 0, 0, 10221, 10222, 7, 11, 0, 0, 10222, + 10223, 7, 6, 0, 0, 10223, 10224, 7, 5, 0, 0, 10224, 10225, 7, 9, 0, 0, + 10225, 1352, 1, 0, 0, 0, 10226, 10227, 7, 3, 0, 0, 10227, 10228, 7, 9, + 0, 0, 10228, 10229, 7, 20, 0, 0, 10229, 10230, 7, 18, 0, 0, 10230, 1354, + 1, 0, 0, 0, 10231, 10232, 7, 3, 0, 0, 10232, 10233, 7, 9, 0, 0, 10233, + 10234, 7, 19, 0, 0, 10234, 10235, 7, 4, 0, 0, 10235, 10236, 7, 11, 0, 0, + 10236, 10237, 7, 9, 0, 0, 10237, 1356, 1, 0, 0, 0, 10238, 10239, 7, 3, + 0, 0, 10239, 10240, 7, 9, 0, 0, 10240, 10241, 7, 19, 0, 0, 10241, 10242, + 7, 4, 0, 0, 10242, 10243, 7, 11, 0, 0, 10243, 10244, 7, 9, 0, 0, 10244, + 10245, 5, 95, 0, 0, 10245, 10246, 7, 2, 0, 0, 10246, 10247, 7, 3, 0, 0, + 10247, 10248, 7, 4, 0, 0, 10248, 10249, 7, 14, 0, 0, 10249, 10250, 5, 95, + 0, 0, 10250, 10251, 7, 11, 0, 0, 10251, 10252, 7, 3, 0, 0, 10252, 10253, + 7, 0, 0, 0, 10253, 10254, 7, 8, 0, 0, 10254, 10255, 7, 7, 0, 0, 10255, + 10256, 7, 0, 0, 0, 10256, 10257, 7, 14, 0, 0, 10257, 10258, 7, 11, 0, 0, + 10258, 10259, 7, 6, 0, 0, 10259, 10260, 7, 4, 0, 0, 10260, 10261, 7, 8, + 0, 0, 10261, 10262, 7, 7, 0, 0, 10262, 1358, 1, 0, 0, 0, 10263, 10264, + 7, 3, 0, 0, 10264, 10265, 7, 9, 0, 0, 10265, 10266, 7, 19, 0, 0, 10266, + 10267, 7, 4, 0, 0, 10267, 10268, 7, 11, 0, 0, 10268, 10269, 7, 9, 0, 0, + 10269, 10270, 5, 95, 0, 0, 10270, 10271, 7, 7, 0, 0, 10271, 10272, 7, 9, + 0, 0, 10272, 10273, 7, 3, 0, 0, 10273, 10274, 7, 5, 0, 0, 10274, 10275, + 7, 6, 0, 0, 10275, 10276, 7, 14, 0, 0, 10276, 10277, 7, 9, 0, 0, 10277, + 10278, 5, 95, 0, 0, 10278, 10279, 7, 8, 0, 0, 10279, 10280, 7, 0, 0, 0, + 10280, 10281, 7, 19, 0, 0, 10281, 10282, 7, 9, 0, 0, 10282, 1360, 1, 0, + 0, 0, 10283, 10284, 7, 3, 0, 0, 10284, 10285, 7, 9, 0, 0, 10285, 10286, + 7, 19, 0, 0, 10286, 10287, 7, 4, 0, 0, 10287, 10288, 7, 5, 0, 0, 10288, + 10289, 7, 9, 0, 0, 10289, 1362, 1, 0, 0, 0, 10290, 10291, 7, 3, 0, 0, 10291, + 10292, 7, 9, 0, 0, 10292, 10293, 7, 8, 0, 0, 10293, 10294, 7, 0, 0, 0, + 10294, 10295, 7, 19, 0, 0, 10295, 10296, 7, 9, 0, 0, 10296, 1364, 1, 0, + 0, 0, 10297, 10298, 7, 3, 0, 0, 10298, 10299, 7, 9, 0, 0, 10299, 10300, + 7, 2, 0, 0, 10300, 10301, 7, 9, 0, 0, 10301, 10302, 7, 0, 0, 0, 10302, + 10303, 7, 11, 0, 0, 10303, 10304, 7, 0, 0, 0, 10304, 10305, 7, 10, 0, 0, + 10305, 10306, 7, 20, 0, 0, 10306, 10307, 7, 9, 0, 0, 10307, 1366, 1, 0, + 0, 0, 10308, 10309, 7, 3, 0, 0, 10309, 10310, 7, 9, 0, 0, 10310, 10311, + 7, 2, 0, 0, 10311, 10312, 7, 20, 0, 0, 10312, 10313, 7, 0, 0, 0, 10313, + 10314, 7, 14, 0, 0, 10314, 10315, 7, 9, 0, 0, 10315, 1368, 1, 0, 0, 0, + 10316, 10317, 7, 3, 0, 0, 10317, 10318, 7, 9, 0, 0, 10318, 10319, 7, 2, + 0, 0, 10319, 10320, 7, 20, 0, 0, 10320, 10321, 7, 0, 0, 0, 10321, 10322, + 7, 14, 0, 0, 10322, 10323, 7, 9, 0, 0, 10323, 10324, 5, 95, 0, 0, 10324, + 10325, 7, 6, 0, 0, 10325, 10326, 7, 8, 0, 0, 10326, 10327, 7, 5, 0, 0, + 10327, 10328, 7, 0, 0, 0, 10328, 10329, 7, 20, 0, 0, 10329, 10330, 7, 6, + 0, 0, 10330, 10331, 7, 1, 0, 0, 10331, 10332, 5, 95, 0, 0, 10332, 10333, + 7, 14, 0, 0, 10333, 10334, 7, 15, 0, 0, 10334, 10335, 7, 0, 0, 0, 10335, + 10336, 7, 3, 0, 0, 10336, 10337, 7, 0, 0, 0, 10337, 10338, 7, 14, 0, 0, + 10338, 10339, 7, 11, 0, 0, 10339, 10340, 7, 9, 0, 0, 10340, 10341, 7, 3, + 0, 0, 10341, 10342, 7, 7, 0, 0, 10342, 1370, 1, 0, 0, 0, 10343, 10344, + 7, 3, 0, 0, 10344, 10345, 7, 9, 0, 0, 10345, 10346, 7, 2, 0, 0, 10346, + 10347, 7, 20, 0, 0, 10347, 10348, 7, 6, 0, 0, 10348, 10349, 7, 14, 0, 0, + 10349, 10350, 7, 0, 0, 0, 10350, 1372, 1, 0, 0, 0, 10351, 10352, 7, 3, + 0, 0, 10352, 10353, 7, 9, 0, 0, 10353, 10354, 7, 2, 0, 0, 10354, 10355, + 7, 20, 0, 0, 10355, 10356, 7, 6, 0, 0, 10356, 10357, 7, 14, 0, 0, 10357, + 10358, 7, 0, 0, 0, 10358, 10359, 7, 11, 0, 0, 10359, 10360, 7, 6, 0, 0, + 10360, 10361, 7, 4, 0, 0, 10361, 10362, 7, 8, 0, 0, 10362, 1374, 1, 0, + 0, 0, 10363, 10364, 7, 3, 0, 0, 10364, 10365, 7, 9, 0, 0, 10365, 10366, + 7, 2, 0, 0, 10366, 10367, 7, 20, 0, 0, 10367, 10368, 7, 6, 0, 0, 10368, + 10369, 7, 14, 0, 0, 10369, 10370, 7, 0, 0, 0, 10370, 10371, 7, 11, 0, 0, + 10371, 10372, 7, 6, 0, 0, 10372, 10373, 7, 4, 0, 0, 10373, 10374, 7, 8, + 0, 0, 10374, 10375, 5, 95, 0, 0, 10375, 10376, 7, 7, 0, 0, 10376, 10377, + 7, 14, 0, 0, 10377, 10378, 7, 15, 0, 0, 10378, 10379, 7, 9, 0, 0, 10379, + 10380, 7, 1, 0, 0, 10380, 10381, 7, 17, 0, 0, 10381, 10382, 7, 20, 0, 0, + 10382, 10383, 7, 9, 0, 0, 10383, 1376, 1, 0, 0, 0, 10384, 10385, 7, 3, + 0, 0, 10385, 10386, 7, 9, 0, 0, 10386, 10387, 7, 16, 0, 0, 10387, 10388, + 7, 17, 0, 0, 10388, 10389, 7, 9, 0, 0, 10389, 10390, 7, 7, 0, 0, 10390, + 10391, 7, 11, 0, 0, 10391, 10392, 5, 95, 0, 0, 10392, 10393, 7, 11, 0, + 0, 10393, 10394, 7, 3, 0, 0, 10394, 10395, 7, 0, 0, 0, 10395, 10396, 7, + 8, 0, 0, 10396, 10397, 7, 7, 0, 0, 10397, 10398, 7, 20, 0, 0, 10398, 10399, + 7, 0, 0, 0, 10399, 10400, 7, 11, 0, 0, 10400, 10401, 7, 4, 0, 0, 10401, + 10402, 7, 3, 0, 0, 10402, 1378, 1, 0, 0, 0, 10403, 10404, 7, 3, 0, 0, 10404, + 10405, 7, 9, 0, 0, 10405, 10406, 7, 16, 0, 0, 10406, 10407, 7, 17, 0, 0, + 10407, 10408, 7, 6, 0, 0, 10408, 10409, 7, 3, 0, 0, 10409, 10410, 7, 9, + 0, 0, 10410, 10411, 7, 1, 0, 0, 10411, 1380, 1, 0, 0, 0, 10412, 10413, + 7, 3, 0, 0, 10413, 10414, 7, 9, 0, 0, 10414, 10415, 7, 16, 0, 0, 10415, + 10416, 7, 17, 0, 0, 10416, 10417, 7, 6, 0, 0, 10417, 10418, 7, 3, 0, 0, + 10418, 10419, 7, 9, 0, 0, 10419, 10420, 5, 95, 0, 0, 10420, 10421, 7, 7, + 0, 0, 10421, 10422, 7, 11, 0, 0, 10422, 10423, 7, 4, 0, 0, 10423, 10424, + 7, 3, 0, 0, 10424, 10425, 7, 0, 0, 0, 10425, 10426, 7, 21, 0, 0, 10426, + 10427, 7, 9, 0, 0, 10427, 10428, 5, 95, 0, 0, 10428, 10429, 7, 6, 0, 0, + 10429, 10430, 7, 8, 0, 0, 10430, 10431, 7, 11, 0, 0, 10431, 10432, 7, 9, + 0, 0, 10432, 10433, 7, 21, 0, 0, 10433, 10434, 7, 3, 0, 0, 10434, 10435, + 7, 0, 0, 0, 10435, 10436, 7, 11, 0, 0, 10436, 10437, 7, 6, 0, 0, 10437, + 10438, 7, 4, 0, 0, 10438, 10439, 7, 8, 0, 0, 10439, 10440, 5, 95, 0, 0, + 10440, 10441, 7, 12, 0, 0, 10441, 10442, 7, 4, 0, 0, 10442, 10443, 7, 3, + 0, 0, 10443, 10444, 5, 95, 0, 0, 10444, 10445, 7, 7, 0, 0, 10445, 10446, + 7, 11, 0, 0, 10446, 10447, 7, 0, 0, 0, 10447, 10448, 7, 21, 0, 0, 10448, + 10449, 7, 9, 0, 0, 10449, 10450, 5, 95, 0, 0, 10450, 10451, 7, 14, 0, 0, + 10451, 10452, 7, 3, 0, 0, 10452, 10453, 7, 9, 0, 0, 10453, 10454, 7, 0, + 0, 0, 10454, 10455, 7, 11, 0, 0, 10455, 10456, 7, 6, 0, 0, 10456, 10457, + 7, 4, 0, 0, 10457, 10458, 7, 8, 0, 0, 10458, 1382, 1, 0, 0, 0, 10459, 10460, + 7, 3, 0, 0, 10460, 10461, 7, 9, 0, 0, 10461, 10462, 7, 16, 0, 0, 10462, + 10463, 7, 17, 0, 0, 10463, 10464, 7, 6, 0, 0, 10464, 10465, 7, 3, 0, 0, + 10465, 10466, 7, 9, 0, 0, 10466, 10467, 5, 95, 0, 0, 10467, 10468, 7, 7, + 0, 0, 10468, 10469, 7, 11, 0, 0, 10469, 10470, 7, 4, 0, 0, 10470, 10471, + 7, 3, 0, 0, 10471, 10472, 7, 0, 0, 0, 10472, 10473, 7, 21, 0, 0, 10473, + 10474, 7, 9, 0, 0, 10474, 10475, 5, 95, 0, 0, 10475, 10476, 7, 6, 0, 0, + 10476, 10477, 7, 8, 0, 0, 10477, 10478, 7, 11, 0, 0, 10478, 10479, 7, 9, + 0, 0, 10479, 10480, 7, 21, 0, 0, 10480, 10481, 7, 3, 0, 0, 10481, 10482, + 7, 0, 0, 0, 10482, 10483, 7, 11, 0, 0, 10483, 10484, 7, 6, 0, 0, 10484, + 10485, 7, 4, 0, 0, 10485, 10486, 7, 8, 0, 0, 10486, 10487, 5, 95, 0, 0, + 10487, 10488, 7, 12, 0, 0, 10488, 10489, 7, 4, 0, 0, 10489, 10490, 7, 3, + 0, 0, 10490, 10491, 5, 95, 0, 0, 10491, 10492, 7, 7, 0, 0, 10492, 10493, + 7, 11, 0, 0, 10493, 10494, 7, 0, 0, 0, 10494, 10495, 7, 21, 0, 0, 10495, + 10496, 7, 9, 0, 0, 10496, 10497, 5, 95, 0, 0, 10497, 10498, 7, 4, 0, 0, + 10498, 10499, 7, 2, 0, 0, 10499, 10500, 7, 9, 0, 0, 10500, 10501, 7, 3, + 0, 0, 10501, 10502, 7, 0, 0, 0, 10502, 10503, 7, 11, 0, 0, 10503, 10504, + 7, 6, 0, 0, 10504, 10505, 7, 4, 0, 0, 10505, 10506, 7, 8, 0, 0, 10506, + 1384, 1, 0, 0, 0, 10507, 10508, 7, 3, 0, 0, 10508, 10509, 7, 9, 0, 0, 10509, + 10510, 7, 7, 0, 0, 10510, 10511, 7, 9, 0, 0, 10511, 10512, 7, 11, 0, 0, + 10512, 1386, 1, 0, 0, 0, 10513, 10514, 7, 3, 0, 0, 10514, 10515, 7, 9, + 0, 0, 10515, 10516, 7, 7, 0, 0, 10516, 10517, 7, 4, 0, 0, 10517, 10518, + 7, 17, 0, 0, 10518, 10519, 7, 3, 0, 0, 10519, 10520, 7, 14, 0, 0, 10520, + 10521, 7, 9, 0, 0, 10521, 1388, 1, 0, 0, 0, 10522, 10523, 7, 3, 0, 0, 10523, + 10524, 7, 9, 0, 0, 10524, 10525, 7, 7, 0, 0, 10525, 10526, 7, 4, 0, 0, + 10526, 10527, 7, 17, 0, 0, 10527, 10528, 7, 3, 0, 0, 10528, 10529, 7, 14, + 0, 0, 10529, 10530, 7, 9, 0, 0, 10530, 10531, 7, 7, 0, 0, 10531, 1390, + 1, 0, 0, 0, 10532, 10533, 7, 3, 0, 0, 10533, 10534, 7, 9, 0, 0, 10534, + 10535, 7, 7, 0, 0, 10535, 10536, 7, 4, 0, 0, 10536, 10537, 7, 17, 0, 0, + 10537, 10538, 7, 3, 0, 0, 10538, 10539, 7, 14, 0, 0, 10539, 10540, 7, 9, + 0, 0, 10540, 10541, 5, 95, 0, 0, 10541, 10542, 7, 19, 0, 0, 10542, 10543, + 7, 4, 0, 0, 10543, 10544, 7, 8, 0, 0, 10544, 10545, 7, 6, 0, 0, 10545, + 10546, 7, 11, 0, 0, 10546, 10547, 7, 4, 0, 0, 10547, 10548, 7, 3, 0, 0, + 10548, 1392, 1, 0, 0, 0, 10549, 10550, 7, 3, 0, 0, 10550, 10551, 7, 9, + 0, 0, 10551, 10552, 7, 7, 0, 0, 10552, 10553, 7, 2, 0, 0, 10553, 10554, + 7, 4, 0, 0, 10554, 10555, 7, 8, 0, 0, 10555, 10556, 7, 7, 0, 0, 10556, + 10557, 7, 9, 0, 0, 10557, 10558, 5, 95, 0, 0, 10558, 10559, 7, 11, 0, 0, + 10559, 10560, 7, 3, 0, 0, 10560, 10561, 7, 0, 0, 0, 10561, 10562, 7, 8, + 0, 0, 10562, 10563, 7, 7, 0, 0, 10563, 10564, 7, 20, 0, 0, 10564, 10565, + 7, 0, 0, 0, 10565, 10566, 7, 11, 0, 0, 10566, 10567, 7, 4, 0, 0, 10567, + 10568, 7, 3, 0, 0, 10568, 1394, 1, 0, 0, 0, 10569, 10570, 7, 3, 0, 0, 10570, + 10571, 7, 9, 0, 0, 10571, 10572, 7, 7, 0, 0, 10572, 10573, 7, 11, 0, 0, + 10573, 10574, 7, 0, 0, 0, 10574, 10575, 7, 3, 0, 0, 10575, 10576, 7, 11, + 0, 0, 10576, 1396, 1, 0, 0, 0, 10577, 10578, 7, 3, 0, 0, 10578, 10579, + 7, 9, 0, 0, 10579, 10580, 7, 7, 0, 0, 10580, 10581, 7, 11, 0, 0, 10581, + 10582, 7, 4, 0, 0, 10582, 10583, 7, 3, 0, 0, 10583, 10584, 7, 9, 0, 0, + 10584, 1398, 1, 0, 0, 0, 10585, 10586, 7, 3, 0, 0, 10586, 10587, 7, 9, + 0, 0, 10587, 10588, 7, 7, 0, 0, 10588, 10589, 7, 11, 0, 0, 10589, 10590, + 7, 3, 0, 0, 10590, 10591, 7, 6, 0, 0, 10591, 10592, 7, 14, 0, 0, 10592, + 10593, 7, 11, 0, 0, 10593, 1400, 1, 0, 0, 0, 10594, 10595, 7, 3, 0, 0, + 10595, 10596, 7, 9, 0, 0, 10596, 10597, 7, 7, 0, 0, 10597, 10598, 7, 11, + 0, 0, 10598, 10599, 7, 3, 0, 0, 10599, 10600, 7, 6, 0, 0, 10600, 10601, + 7, 14, 0, 0, 10601, 10602, 7, 11, 0, 0, 10602, 10603, 7, 6, 0, 0, 10603, + 10604, 7, 4, 0, 0, 10604, 10605, 7, 8, 0, 0, 10605, 10606, 7, 7, 0, 0, + 10606, 1402, 1, 0, 0, 0, 10607, 10608, 7, 3, 0, 0, 10608, 10609, 7, 9, + 0, 0, 10609, 10610, 7, 7, 0, 0, 10610, 10611, 7, 17, 0, 0, 10611, 10612, + 7, 20, 0, 0, 10612, 10613, 7, 11, 0, 0, 10613, 1404, 1, 0, 0, 0, 10614, + 10615, 7, 3, 0, 0, 10615, 10616, 7, 9, 0, 0, 10616, 10617, 7, 7, 0, 0, + 10617, 10618, 7, 17, 0, 0, 10618, 10619, 7, 19, 0, 0, 10619, 10620, 7, + 9, 0, 0, 10620, 1406, 1, 0, 0, 0, 10621, 10622, 7, 3, 0, 0, 10622, 10623, + 7, 9, 0, 0, 10623, 10624, 7, 11, 0, 0, 10624, 10625, 7, 0, 0, 0, 10625, + 10626, 7, 6, 0, 0, 10626, 10627, 7, 8, 0, 0, 10627, 10628, 7, 1, 0, 0, + 10628, 10629, 7, 0, 0, 0, 10629, 10630, 7, 18, 0, 0, 10630, 10631, 7, 7, + 0, 0, 10631, 1408, 1, 0, 0, 0, 10632, 10633, 7, 3, 0, 0, 10633, 10634, + 7, 9, 0, 0, 10634, 10635, 7, 11, 0, 0, 10635, 10636, 7, 17, 0, 0, 10636, + 10637, 7, 3, 0, 0, 10637, 10638, 7, 8, 0, 0, 10638, 1410, 1, 0, 0, 0, 10639, + 10640, 7, 3, 0, 0, 10640, 10641, 7, 9, 0, 0, 10641, 10642, 7, 11, 0, 0, + 10642, 10643, 7, 17, 0, 0, 10643, 10644, 7, 3, 0, 0, 10644, 10645, 7, 8, + 0, 0, 10645, 10646, 7, 7, 0, 0, 10646, 1412, 1, 0, 0, 0, 10647, 10648, + 7, 3, 0, 0, 10648, 10649, 7, 9, 0, 0, 10649, 10650, 7, 11, 0, 0, 10650, + 10651, 7, 17, 0, 0, 10651, 10652, 7, 3, 0, 0, 10652, 10653, 7, 8, 0, 0, + 10653, 10654, 5, 95, 0, 0, 10654, 10655, 7, 0, 0, 0, 10655, 10656, 7, 20, + 0, 0, 10656, 10657, 7, 20, 0, 0, 10657, 10658, 5, 95, 0, 0, 10658, 10659, + 7, 9, 0, 0, 10659, 10660, 7, 3, 0, 0, 10660, 10661, 7, 3, 0, 0, 10661, + 10662, 7, 4, 0, 0, 10662, 10663, 7, 3, 0, 0, 10663, 10664, 7, 7, 0, 0, + 10664, 1414, 1, 0, 0, 0, 10665, 10666, 7, 3, 0, 0, 10666, 10667, 7, 9, + 0, 0, 10667, 10668, 7, 11, 0, 0, 10668, 10669, 7, 17, 0, 0, 10669, 10670, + 7, 3, 0, 0, 10670, 10671, 7, 8, 0, 0, 10671, 10672, 5, 95, 0, 0, 10672, + 10673, 7, 9, 0, 0, 10673, 10674, 7, 3, 0, 0, 10674, 10675, 7, 3, 0, 0, + 10675, 10676, 7, 4, 0, 0, 10676, 10677, 7, 3, 0, 0, 10677, 10678, 7, 7, + 0, 0, 10678, 1416, 1, 0, 0, 0, 10679, 10680, 7, 3, 0, 0, 10680, 10681, + 7, 9, 0, 0, 10681, 10682, 7, 11, 0, 0, 10682, 10683, 7, 17, 0, 0, 10683, + 10684, 7, 3, 0, 0, 10684, 10685, 7, 8, 0, 0, 10685, 10686, 5, 95, 0, 0, + 10686, 10687, 7, 12, 0, 0, 10687, 10688, 7, 0, 0, 0, 10688, 10689, 7, 6, + 0, 0, 10689, 10690, 7, 20, 0, 0, 10690, 10691, 7, 9, 0, 0, 10691, 10692, + 7, 1, 0, 0, 10692, 10693, 5, 95, 0, 0, 10693, 10694, 7, 4, 0, 0, 10694, + 10695, 7, 8, 0, 0, 10695, 10696, 7, 20, 0, 0, 10696, 10697, 7, 18, 0, 0, + 10697, 1418, 1, 0, 0, 0, 10698, 10699, 7, 3, 0, 0, 10699, 10700, 7, 9, + 0, 0, 10700, 10701, 7, 11, 0, 0, 10701, 10702, 7, 17, 0, 0, 10702, 10703, + 7, 3, 0, 0, 10703, 10704, 7, 8, 0, 0, 10704, 10705, 5, 95, 0, 0, 10705, + 10707, 1, 0, 0, 0, 10706, 10708, 3, 2247, 1123, 0, 10707, 10706, 1, 0, + 0, 0, 10708, 10709, 1, 0, 0, 0, 10709, 10707, 1, 0, 0, 0, 10709, 10710, + 1, 0, 0, 0, 10710, 10711, 1, 0, 0, 0, 10711, 10712, 5, 95, 0, 0, 10712, + 10713, 7, 3, 0, 0, 10713, 10714, 7, 4, 0, 0, 10714, 10715, 7, 13, 0, 0, + 10715, 10716, 7, 7, 0, 0, 10716, 1420, 1, 0, 0, 0, 10717, 10718, 7, 3, + 0, 0, 10718, 10719, 7, 9, 0, 0, 10719, 10720, 7, 11, 0, 0, 10720, 10721, + 7, 17, 0, 0, 10721, 10722, 7, 3, 0, 0, 10722, 10723, 7, 8, 0, 0, 10723, + 10724, 5, 95, 0, 0, 10724, 10725, 7, 3, 0, 0, 10725, 10726, 7, 4, 0, 0, + 10726, 10727, 7, 13, 0, 0, 10727, 10728, 7, 7, 0, 0, 10728, 1422, 1, 0, + 0, 0, 10729, 10730, 7, 3, 0, 0, 10730, 10731, 7, 9, 0, 0, 10731, 10732, + 7, 5, 0, 0, 10732, 10733, 7, 9, 0, 0, 10733, 10734, 7, 3, 0, 0, 10734, + 10735, 7, 7, 0, 0, 10735, 10736, 7, 9, 0, 0, 10736, 1424, 1, 0, 0, 0, 10737, + 10738, 7, 3, 0, 0, 10738, 10739, 7, 9, 0, 0, 10739, 10740, 7, 5, 0, 0, + 10740, 10741, 7, 9, 0, 0, 10741, 10742, 7, 3, 0, 0, 10742, 10743, 7, 11, + 0, 0, 10743, 1426, 1, 0, 0, 0, 10744, 10745, 7, 3, 0, 0, 10745, 10746, + 7, 9, 0, 0, 10746, 10747, 7, 5, 0, 0, 10747, 10748, 7, 4, 0, 0, 10748, + 10749, 7, 22, 0, 0, 10749, 10750, 7, 9, 0, 0, 10750, 1428, 1, 0, 0, 0, + 10751, 10752, 7, 3, 0, 0, 10752, 10753, 7, 9, 0, 0, 10753, 10754, 7, 13, + 0, 0, 10754, 10755, 7, 6, 0, 0, 10755, 10756, 7, 8, 0, 0, 10756, 10757, + 7, 1, 0, 0, 10757, 1430, 1, 0, 0, 0, 10758, 10759, 7, 3, 0, 0, 10759, 10760, + 7, 6, 0, 0, 10760, 10761, 7, 21, 0, 0, 10761, 10762, 7, 15, 0, 0, 10762, + 10763, 7, 11, 0, 0, 10763, 1432, 1, 0, 0, 0, 10764, 10765, 7, 3, 0, 0, + 10765, 10766, 7, 20, 0, 0, 10766, 10767, 7, 6, 0, 0, 10767, 10768, 7, 22, + 0, 0, 10768, 10769, 7, 9, 0, 0, 10769, 1434, 1, 0, 0, 0, 10770, 10771, + 7, 3, 0, 0, 10771, 10772, 7, 4, 0, 0, 10772, 10773, 7, 20, 0, 0, 10773, + 10774, 7, 9, 0, 0, 10774, 1436, 1, 0, 0, 0, 10775, 10776, 7, 3, 0, 0, 10776, + 10777, 7, 4, 0, 0, 10777, 10778, 7, 20, 0, 0, 10778, 10779, 7, 9, 0, 0, + 10779, 10780, 7, 7, 0, 0, 10780, 1438, 1, 0, 0, 0, 10781, 10782, 7, 3, + 0, 0, 10782, 10783, 7, 4, 0, 0, 10783, 10784, 7, 20, 0, 0, 10784, 10785, + 7, 20, 0, 0, 10785, 10786, 7, 10, 0, 0, 10786, 10787, 7, 0, 0, 0, 10787, + 10788, 7, 14, 0, 0, 10788, 10789, 7, 22, 0, 0, 10789, 1440, 1, 0, 0, 0, + 10790, 10791, 7, 3, 0, 0, 10791, 10792, 7, 4, 0, 0, 10792, 10793, 7, 20, + 0, 0, 10793, 10794, 7, 20, 0, 0, 10794, 10795, 7, 17, 0, 0, 10795, 10796, + 7, 2, 0, 0, 10796, 1442, 1, 0, 0, 0, 10797, 10798, 7, 3, 0, 0, 10798, 10799, + 7, 4, 0, 0, 10799, 10800, 7, 4, 0, 0, 10800, 10801, 7, 11, 0, 0, 10801, + 1444, 1, 0, 0, 0, 10802, 10803, 7, 3, 0, 0, 10803, 10804, 7, 4, 0, 0, 10804, + 10805, 7, 13, 0, 0, 10805, 1446, 1, 0, 0, 0, 10806, 10807, 7, 3, 0, 0, + 10807, 10808, 7, 4, 0, 0, 10808, 10809, 7, 13, 0, 0, 10809, 10810, 7, 14, + 0, 0, 10810, 10811, 7, 4, 0, 0, 10811, 10812, 7, 17, 0, 0, 10812, 10813, + 7, 8, 0, 0, 10813, 10814, 7, 11, 0, 0, 10814, 1448, 1, 0, 0, 0, 10815, + 10816, 7, 3, 0, 0, 10816, 10817, 7, 4, 0, 0, 10817, 10818, 7, 13, 0, 0, + 10818, 10819, 7, 21, 0, 0, 10819, 10820, 7, 17, 0, 0, 10820, 10821, 7, + 6, 0, 0, 10821, 10822, 7, 1, 0, 0, 10822, 1450, 1, 0, 0, 0, 10823, 10824, + 7, 3, 0, 0, 10824, 10825, 7, 4, 0, 0, 10825, 10826, 7, 13, 0, 0, 10826, + 10827, 7, 20, 0, 0, 10827, 10828, 7, 4, 0, 0, 10828, 10829, 7, 14, 0, 0, + 10829, 10830, 7, 22, 0, 0, 10830, 1452, 1, 0, 0, 0, 10831, 10832, 7, 3, + 0, 0, 10832, 10833, 7, 4, 0, 0, 10833, 10834, 7, 13, 0, 0, 10834, 10835, + 7, 7, 0, 0, 10835, 1454, 1, 0, 0, 0, 10836, 10837, 7, 3, 0, 0, 10837, 10838, + 7, 4, 0, 0, 10838, 10839, 7, 13, 0, 0, 10839, 10840, 7, 7, 0, 0, 10840, + 10841, 5, 95, 0, 0, 10841, 10842, 7, 2, 0, 0, 10842, 10843, 7, 9, 0, 0, + 10843, 10844, 7, 3, 0, 0, 10844, 10845, 5, 95, 0, 0, 10845, 10846, 7, 3, + 0, 0, 10846, 10847, 7, 9, 0, 0, 10847, 10848, 7, 7, 0, 0, 10848, 10849, + 7, 17, 0, 0, 10849, 10850, 7, 20, 0, 0, 10850, 10851, 7, 11, 0, 0, 10851, + 10852, 7, 7, 0, 0, 10852, 10853, 7, 9, 0, 0, 10853, 10854, 7, 11, 0, 0, + 10854, 1456, 1, 0, 0, 0, 10855, 10856, 7, 3, 0, 0, 10856, 10857, 7, 4, + 0, 0, 10857, 10858, 7, 13, 0, 0, 10858, 10859, 5, 95, 0, 0, 10859, 10860, + 7, 8, 0, 0, 10860, 10861, 7, 17, 0, 0, 10861, 10862, 7, 19, 0, 0, 10862, + 10863, 7, 10, 0, 0, 10863, 10864, 7, 9, 0, 0, 10864, 10865, 7, 3, 0, 0, + 10865, 1458, 1, 0, 0, 0, 10866, 10867, 7, 3, 0, 0, 10867, 10868, 7, 7, + 0, 0, 10868, 10869, 7, 0, 0, 0, 10869, 10870, 5, 95, 0, 0, 10870, 10871, + 7, 2, 0, 0, 10871, 10872, 7, 17, 0, 0, 10872, 10873, 7, 10, 0, 0, 10873, + 10874, 7, 20, 0, 0, 10874, 10875, 7, 6, 0, 0, 10875, 10876, 7, 14, 0, 0, + 10876, 10877, 5, 95, 0, 0, 10877, 10878, 7, 22, 0, 0, 10878, 10879, 7, + 9, 0, 0, 10879, 10880, 7, 18, 0, 0, 10880, 1460, 1, 0, 0, 0, 10881, 10882, + 7, 3, 0, 0, 10882, 10883, 7, 7, 0, 0, 10883, 10884, 7, 0, 0, 0, 10884, + 10885, 5, 95, 0, 0, 10885, 10886, 7, 2, 0, 0, 10886, 10887, 7, 17, 0, 0, + 10887, 10888, 7, 10, 0, 0, 10888, 10889, 7, 20, 0, 0, 10889, 10890, 7, + 6, 0, 0, 10890, 10891, 7, 14, 0, 0, 10891, 10892, 5, 95, 0, 0, 10892, 10893, + 7, 22, 0, 0, 10893, 10894, 7, 9, 0, 0, 10894, 10895, 7, 18, 0, 0, 10895, + 10896, 5, 95, 0, 0, 10896, 10897, 5, 50, 0, 0, 10897, 1462, 1, 0, 0, 0, + 10898, 10899, 7, 3, 0, 0, 10899, 10900, 7, 11, 0, 0, 10900, 10901, 7, 3, + 0, 0, 10901, 10902, 7, 6, 0, 0, 10902, 10903, 7, 19, 0, 0, 10903, 1464, + 1, 0, 0, 0, 10904, 10905, 7, 3, 0, 0, 10905, 10906, 7, 17, 0, 0, 10906, + 10907, 7, 8, 0, 0, 10907, 10908, 5, 95, 0, 0, 10908, 10909, 7, 0, 0, 0, + 10909, 10910, 7, 7, 0, 0, 10910, 10911, 5, 95, 0, 0, 10911, 10912, 7, 3, + 0, 0, 10912, 10913, 7, 4, 0, 0, 10913, 10914, 7, 20, 0, 0, 10914, 10915, + 7, 9, 0, 0, 10915, 1466, 1, 0, 0, 0, 10916, 10917, 5, 39, 0, 0, 10917, + 10918, 7, 7, 0, 0, 10918, 10919, 5, 51, 0, 0, 10919, 10920, 5, 39, 0, 0, + 10920, 1468, 1, 0, 0, 0, 10921, 10922, 7, 7, 0, 0, 10922, 10923, 7, 0, + 0, 0, 10923, 10924, 7, 12, 0, 0, 10924, 10925, 7, 9, 0, 0, 10925, 1470, + 1, 0, 0, 0, 10926, 10927, 7, 7, 0, 0, 10927, 10928, 7, 0, 0, 0, 10928, + 10929, 7, 12, 0, 0, 10929, 10930, 7, 9, 0, 0, 10930, 10931, 7, 11, 0, 0, + 10931, 10932, 7, 18, 0, 0, 10932, 1472, 1, 0, 0, 0, 10933, 10934, 7, 7, + 0, 0, 10934, 10935, 7, 0, 0, 0, 10935, 10936, 7, 19, 0, 0, 10936, 10937, + 7, 20, 0, 0, 10937, 10938, 5, 50, 0, 0, 10938, 1474, 1, 0, 0, 0, 10939, + 10940, 7, 7, 0, 0, 10940, 10941, 7, 0, 0, 0, 10941, 10942, 7, 19, 0, 0, + 10942, 10943, 7, 20, 0, 0, 10943, 10944, 5, 50, 0, 0, 10944, 10945, 5, + 95, 0, 0, 10945, 10946, 7, 9, 0, 0, 10946, 10947, 7, 8, 0, 0, 10947, 10948, + 7, 0, 0, 0, 10948, 10949, 7, 10, 0, 0, 10949, 10950, 7, 20, 0, 0, 10950, + 10951, 7, 9, 0, 0, 10951, 10952, 5, 95, 0, 0, 10952, 10953, 7, 7, 0, 0, + 10953, 10954, 7, 2, 0, 0, 10954, 10955, 5, 95, 0, 0, 10955, 10956, 7, 6, + 0, 0, 10956, 10957, 7, 8, 0, 0, 10957, 10958, 7, 6, 0, 0, 10958, 10959, + 7, 11, 0, 0, 10959, 10960, 7, 6, 0, 0, 10960, 10961, 7, 0, 0, 0, 10961, + 10962, 7, 11, 0, 0, 10962, 10963, 7, 9, 0, 0, 10963, 10964, 7, 1, 0, 0, + 10964, 1476, 1, 0, 0, 0, 10965, 10966, 7, 7, 0, 0, 10966, 10967, 7, 0, + 0, 0, 10967, 10968, 7, 19, 0, 0, 10968, 10969, 7, 20, 0, 0, 10969, 10970, + 5, 50, 0, 0, 10970, 10971, 5, 95, 0, 0, 10971, 10972, 7, 12, 0, 0, 10972, + 10973, 7, 4, 0, 0, 10973, 10974, 7, 3, 0, 0, 10974, 10975, 7, 14, 0, 0, + 10975, 10976, 7, 9, 0, 0, 10976, 10977, 5, 95, 0, 0, 10977, 10978, 7, 0, + 0, 0, 10978, 10979, 7, 17, 0, 0, 10979, 10980, 7, 11, 0, 0, 10980, 10981, + 7, 15, 0, 0, 10981, 10982, 7, 8, 0, 0, 10982, 1478, 1, 0, 0, 0, 10983, + 10984, 7, 7, 0, 0, 10984, 10985, 7, 0, 0, 0, 10985, 10986, 7, 19, 0, 0, + 10986, 10987, 7, 20, 0, 0, 10987, 10988, 5, 50, 0, 0, 10988, 10989, 5, + 95, 0, 0, 10989, 10990, 7, 6, 0, 0, 10990, 10991, 7, 7, 0, 0, 10991, 10992, + 7, 7, 0, 0, 10992, 10993, 7, 17, 0, 0, 10993, 10994, 7, 9, 0, 0, 10994, + 10995, 7, 3, 0, 0, 10995, 1480, 1, 0, 0, 0, 10996, 10997, 7, 7, 0, 0, 10997, + 10998, 7, 0, 0, 0, 10998, 10999, 7, 19, 0, 0, 10999, 11000, 7, 20, 0, 0, + 11000, 11001, 5, 50, 0, 0, 11001, 11002, 5, 95, 0, 0, 11002, 11003, 7, + 2, 0, 0, 11003, 11004, 7, 4, 0, 0, 11004, 11005, 7, 7, 0, 0, 11005, 11006, + 7, 11, 0, 0, 11006, 11007, 5, 95, 0, 0, 11007, 11008, 7, 20, 0, 0, 11008, + 11009, 7, 4, 0, 0, 11009, 11010, 7, 21, 0, 0, 11010, 11011, 7, 4, 0, 0, + 11011, 11012, 7, 17, 0, 0, 11012, 11013, 7, 11, 0, 0, 11013, 11014, 5, + 95, 0, 0, 11014, 11015, 7, 3, 0, 0, 11015, 11016, 7, 9, 0, 0, 11016, 11017, + 7, 1, 0, 0, 11017, 11018, 7, 6, 0, 0, 11018, 11019, 7, 3, 0, 0, 11019, + 11020, 7, 9, 0, 0, 11020, 11021, 7, 14, 0, 0, 11021, 11022, 7, 11, 0, 0, + 11022, 11023, 5, 95, 0, 0, 11023, 11024, 7, 17, 0, 0, 11024, 11025, 7, + 3, 0, 0, 11025, 11026, 7, 20, 0, 0, 11026, 1482, 1, 0, 0, 0, 11027, 11028, + 7, 7, 0, 0, 11028, 11029, 7, 0, 0, 0, 11029, 11030, 7, 19, 0, 0, 11030, + 11031, 7, 20, 0, 0, 11031, 11032, 5, 50, 0, 0, 11032, 11033, 5, 95, 0, + 0, 11033, 11034, 7, 2, 0, 0, 11034, 11035, 7, 3, 0, 0, 11035, 11036, 7, + 4, 0, 0, 11036, 11037, 7, 5, 0, 0, 11037, 11038, 7, 6, 0, 0, 11038, 11039, + 7, 1, 0, 0, 11039, 11040, 7, 9, 0, 0, 11040, 11041, 7, 3, 0, 0, 11041, + 1484, 1, 0, 0, 0, 11042, 11043, 7, 7, 0, 0, 11043, 11044, 7, 0, 0, 0, 11044, + 11045, 7, 19, 0, 0, 11045, 11046, 7, 20, 0, 0, 11046, 11047, 5, 50, 0, + 0, 11047, 11048, 5, 95, 0, 0, 11048, 11049, 7, 3, 0, 0, 11049, 11050, 7, + 9, 0, 0, 11050, 11051, 7, 16, 0, 0, 11051, 11052, 7, 17, 0, 0, 11052, 11053, + 7, 9, 0, 0, 11053, 11054, 7, 7, 0, 0, 11054, 11055, 7, 11, 0, 0, 11055, + 11056, 7, 9, 0, 0, 11056, 11057, 7, 1, 0, 0, 11057, 11058, 5, 95, 0, 0, + 11058, 11059, 7, 8, 0, 0, 11059, 11060, 7, 0, 0, 0, 11060, 11061, 7, 19, + 0, 0, 11061, 11062, 7, 9, 0, 0, 11062, 11063, 7, 6, 0, 0, 11063, 11064, + 7, 1, 0, 0, 11064, 11065, 5, 95, 0, 0, 11065, 11066, 7, 12, 0, 0, 11066, + 11067, 7, 4, 0, 0, 11067, 11068, 7, 3, 0, 0, 11068, 11069, 7, 19, 0, 0, + 11069, 11070, 7, 0, 0, 0, 11070, 11071, 7, 11, 0, 0, 11071, 1486, 1, 0, + 0, 0, 11072, 11073, 7, 7, 0, 0, 11073, 11074, 7, 0, 0, 0, 11074, 11075, + 7, 19, 0, 0, 11075, 11076, 7, 20, 0, 0, 11076, 11077, 5, 50, 0, 0, 11077, + 11078, 5, 95, 0, 0, 11078, 11079, 7, 7, 0, 0, 11079, 11080, 7, 6, 0, 0, + 11080, 11081, 7, 21, 0, 0, 11081, 11082, 7, 8, 0, 0, 11082, 11083, 5, 95, + 0, 0, 11083, 11084, 7, 3, 0, 0, 11084, 11085, 7, 9, 0, 0, 11085, 11086, + 7, 16, 0, 0, 11086, 11087, 7, 17, 0, 0, 11087, 11088, 7, 9, 0, 0, 11088, + 11089, 7, 7, 0, 0, 11089, 11090, 7, 11, 0, 0, 11090, 1488, 1, 0, 0, 0, + 11091, 11092, 7, 7, 0, 0, 11092, 11093, 7, 0, 0, 0, 11093, 11094, 7, 19, + 0, 0, 11094, 11095, 7, 20, 0, 0, 11095, 11096, 5, 50, 0, 0, 11096, 11097, + 5, 95, 0, 0, 11097, 11098, 7, 7, 0, 0, 11098, 11099, 7, 8, 0, 0, 11099, + 11100, 7, 4, 0, 0, 11100, 11101, 7, 13, 0, 0, 11101, 11102, 7, 12, 0, 0, + 11102, 11103, 7, 20, 0, 0, 11103, 11104, 7, 0, 0, 0, 11104, 11105, 7, 22, + 0, 0, 11105, 11106, 7, 9, 0, 0, 11106, 11107, 5, 95, 0, 0, 11107, 11108, + 7, 0, 0, 0, 11108, 11109, 7, 14, 0, 0, 11109, 11110, 7, 7, 0, 0, 11110, + 11111, 5, 95, 0, 0, 11111, 11112, 7, 17, 0, 0, 11112, 11113, 7, 3, 0, 0, + 11113, 11114, 7, 20, 0, 0, 11114, 1490, 1, 0, 0, 0, 11115, 11116, 7, 7, + 0, 0, 11116, 11117, 7, 0, 0, 0, 11117, 11118, 7, 19, 0, 0, 11118, 11119, + 7, 20, 0, 0, 11119, 11120, 5, 50, 0, 0, 11120, 11121, 5, 95, 0, 0, 11121, + 11122, 7, 7, 0, 0, 11122, 11123, 7, 8, 0, 0, 11123, 11124, 7, 4, 0, 0, + 11124, 11125, 7, 13, 0, 0, 11125, 11126, 7, 12, 0, 0, 11126, 11127, 7, + 20, 0, 0, 11127, 11128, 7, 0, 0, 0, 11128, 11129, 7, 22, 0, 0, 11129, 11130, + 7, 9, 0, 0, 11130, 11131, 5, 95, 0, 0, 11131, 11132, 7, 6, 0, 0, 11132, + 11133, 7, 7, 0, 0, 11133, 11134, 7, 7, 0, 0, 11134, 11135, 7, 17, 0, 0, + 11135, 11136, 7, 9, 0, 0, 11136, 11137, 7, 3, 0, 0, 11137, 11138, 5, 95, + 0, 0, 11138, 11139, 7, 17, 0, 0, 11139, 11140, 7, 3, 0, 0, 11140, 11141, + 7, 20, 0, 0, 11141, 1492, 1, 0, 0, 0, 11142, 11143, 7, 7, 0, 0, 11143, + 11144, 7, 0, 0, 0, 11144, 11145, 7, 19, 0, 0, 11145, 11146, 7, 20, 0, 0, + 11146, 11147, 5, 50, 0, 0, 11147, 11148, 5, 95, 0, 0, 11148, 11149, 7, + 7, 0, 0, 11149, 11150, 7, 8, 0, 0, 11150, 11151, 7, 4, 0, 0, 11151, 11152, + 7, 13, 0, 0, 11152, 11153, 7, 12, 0, 0, 11153, 11154, 7, 20, 0, 0, 11154, + 11155, 7, 0, 0, 0, 11155, 11156, 7, 22, 0, 0, 11156, 11157, 7, 9, 0, 0, + 11157, 11158, 5, 95, 0, 0, 11158, 11159, 7, 23, 0, 0, 11159, 11160, 5, + 53, 0, 0, 11160, 11161, 5, 48, 0, 0, 11161, 11162, 5, 57, 0, 0, 11162, + 11163, 5, 95, 0, 0, 11163, 11164, 7, 14, 0, 0, 11164, 11165, 7, 9, 0, 0, + 11165, 11166, 7, 3, 0, 0, 11166, 11167, 7, 11, 0, 0, 11167, 1494, 1, 0, + 0, 0, 11168, 11169, 7, 7, 0, 0, 11169, 11170, 7, 0, 0, 0, 11170, 11171, + 7, 19, 0, 0, 11171, 11172, 7, 20, 0, 0, 11172, 11173, 5, 50, 0, 0, 11173, + 11174, 5, 95, 0, 0, 11174, 11175, 7, 7, 0, 0, 11175, 11176, 7, 2, 0, 0, + 11176, 11177, 5, 95, 0, 0, 11177, 11178, 7, 6, 0, 0, 11178, 11179, 7, 8, + 0, 0, 11179, 11180, 7, 6, 0, 0, 11180, 11181, 7, 11, 0, 0, 11181, 11182, + 7, 6, 0, 0, 11182, 11183, 7, 0, 0, 0, 11183, 11184, 7, 11, 0, 0, 11184, + 11185, 7, 9, 0, 0, 11185, 11186, 7, 1, 0, 0, 11186, 11187, 5, 95, 0, 0, + 11187, 11188, 7, 20, 0, 0, 11188, 11189, 7, 4, 0, 0, 11189, 11190, 7, 21, + 0, 0, 11190, 11191, 7, 6, 0, 0, 11191, 11192, 7, 8, 0, 0, 11192, 11193, + 5, 95, 0, 0, 11193, 11194, 7, 2, 0, 0, 11194, 11195, 7, 0, 0, 0, 11195, + 11196, 7, 21, 0, 0, 11196, 11197, 7, 9, 0, 0, 11197, 11198, 5, 95, 0, 0, + 11198, 11199, 7, 20, 0, 0, 11199, 11200, 7, 0, 0, 0, 11200, 11201, 7, 10, + 0, 0, 11201, 11202, 7, 9, 0, 0, 11202, 11203, 7, 20, 0, 0, 11203, 1496, + 1, 0, 0, 0, 11204, 11205, 7, 7, 0, 0, 11205, 11206, 7, 0, 0, 0, 11206, + 11207, 7, 19, 0, 0, 11207, 11208, 7, 20, 0, 0, 11208, 11209, 5, 50, 0, + 0, 11209, 11210, 5, 95, 0, 0, 11210, 11211, 7, 7, 0, 0, 11211, 11212, 7, + 7, 0, 0, 11212, 11213, 7, 4, 0, 0, 11213, 11214, 5, 95, 0, 0, 11214, 11215, + 7, 17, 0, 0, 11215, 11216, 7, 3, 0, 0, 11216, 11217, 7, 20, 0, 0, 11217, + 1498, 1, 0, 0, 0, 11218, 11219, 7, 7, 0, 0, 11219, 11220, 7, 0, 0, 0, 11220, + 11221, 7, 19, 0, 0, 11221, 11222, 7, 20, 0, 0, 11222, 11223, 5, 50, 0, + 0, 11223, 11224, 5, 95, 0, 0, 11224, 11225, 7, 23, 0, 0, 11225, 11226, + 5, 53, 0, 0, 11226, 11227, 5, 48, 0, 0, 11227, 11228, 5, 57, 0, 0, 11228, + 11229, 5, 95, 0, 0, 11229, 11230, 7, 14, 0, 0, 11230, 11231, 7, 9, 0, 0, + 11231, 11232, 7, 3, 0, 0, 11232, 11233, 7, 11, 0, 0, 11233, 1500, 1, 0, + 0, 0, 11234, 11235, 7, 7, 0, 0, 11235, 11236, 7, 0, 0, 0, 11236, 11237, + 7, 19, 0, 0, 11237, 11238, 7, 20, 0, 0, 11238, 11239, 5, 95, 0, 0, 11239, + 11240, 7, 6, 0, 0, 11240, 11241, 7, 1, 0, 0, 11241, 11242, 7, 9, 0, 0, + 11242, 11243, 7, 8, 0, 0, 11243, 11244, 7, 11, 0, 0, 11244, 11245, 7, 6, + 0, 0, 11245, 11246, 7, 11, 0, 0, 11246, 11247, 7, 18, 0, 0, 11247, 11248, + 5, 95, 0, 0, 11248, 11249, 7, 2, 0, 0, 11249, 11250, 7, 3, 0, 0, 11250, + 11251, 7, 4, 0, 0, 11251, 11252, 7, 5, 0, 0, 11252, 11253, 7, 6, 0, 0, + 11253, 11254, 7, 1, 0, 0, 11254, 11255, 7, 9, 0, 0, 11255, 11256, 7, 3, + 0, 0, 11256, 1502, 1, 0, 0, 0, 11257, 11258, 7, 7, 0, 0, 11258, 11259, + 7, 0, 0, 0, 11259, 11260, 7, 19, 0, 0, 11260, 11261, 7, 2, 0, 0, 11261, + 11262, 7, 20, 0, 0, 11262, 11263, 7, 9, 0, 0, 11263, 1504, 1, 0, 0, 0, + 11264, 11265, 7, 7, 0, 0, 11265, 11266, 7, 0, 0, 0, 11266, 11267, 7, 5, + 0, 0, 11267, 11268, 7, 9, 0, 0, 11268, 11269, 5, 95, 0, 0, 11269, 11270, + 7, 4, 0, 0, 11270, 11271, 7, 20, 0, 0, 11271, 11272, 7, 1, 0, 0, 11272, + 11273, 5, 95, 0, 0, 11273, 11274, 7, 17, 0, 0, 11274, 11275, 7, 3, 0, 0, + 11275, 11276, 7, 20, 0, 0, 11276, 1506, 1, 0, 0, 0, 11277, 11278, 7, 7, + 0, 0, 11278, 11279, 7, 14, 0, 0, 11279, 11280, 7, 0, 0, 0, 11280, 11281, + 7, 20, 0, 0, 11281, 11282, 7, 6, 0, 0, 11282, 11283, 7, 8, 0, 0, 11283, + 11284, 7, 21, 0, 0, 11284, 11285, 5, 95, 0, 0, 11285, 11286, 7, 2, 0, 0, + 11286, 11287, 7, 4, 0, 0, 11287, 11288, 7, 20, 0, 0, 11288, 11289, 7, 6, + 0, 0, 11289, 11290, 7, 14, 0, 0, 11290, 11291, 7, 18, 0, 0, 11291, 1508, + 1, 0, 0, 0, 11292, 11293, 7, 7, 0, 0, 11293, 11294, 7, 14, 0, 0, 11294, + 11295, 7, 15, 0, 0, 11295, 11296, 7, 9, 0, 0, 11296, 11297, 7, 1, 0, 0, + 11297, 11298, 7, 17, 0, 0, 11298, 11299, 7, 20, 0, 0, 11299, 11300, 7, + 9, 0, 0, 11300, 1510, 1, 0, 0, 0, 11301, 11302, 7, 7, 0, 0, 11302, 11303, + 7, 14, 0, 0, 11303, 11304, 7, 15, 0, 0, 11304, 11305, 7, 9, 0, 0, 11305, + 11306, 7, 1, 0, 0, 11306, 11307, 7, 17, 0, 0, 11307, 11308, 7, 20, 0, 0, + 11308, 11309, 7, 9, 0, 0, 11309, 11310, 7, 3, 0, 0, 11310, 1512, 1, 0, + 0, 0, 11311, 11312, 7, 7, 0, 0, 11312, 11313, 7, 14, 0, 0, 11313, 11314, + 7, 15, 0, 0, 11314, 11315, 7, 9, 0, 0, 11315, 11316, 7, 19, 0, 0, 11316, + 11317, 7, 0, 0, 0, 11317, 1514, 1, 0, 0, 0, 11318, 11319, 7, 7, 0, 0, 11319, + 11320, 7, 14, 0, 0, 11320, 11321, 7, 15, 0, 0, 11321, 11322, 7, 9, 0, 0, + 11322, 11323, 7, 19, 0, 0, 11323, 11324, 7, 0, 0, 0, 11324, 11325, 7, 7, + 0, 0, 11325, 1516, 1, 0, 0, 0, 11326, 11327, 7, 7, 0, 0, 11327, 11328, + 7, 14, 0, 0, 11328, 11329, 7, 15, 0, 0, 11329, 11330, 7, 9, 0, 0, 11330, + 11331, 7, 19, 0, 0, 11331, 11332, 7, 9, 0, 0, 11332, 1518, 1, 0, 0, 0, + 11333, 11334, 7, 7, 0, 0, 11334, 11335, 7, 14, 0, 0, 11335, 11336, 7, 6, + 0, 0, 11336, 11337, 7, 19, 0, 0, 11337, 1520, 1, 0, 0, 0, 11338, 11339, + 7, 7, 0, 0, 11339, 11340, 7, 14, 0, 0, 11340, 11341, 7, 6, 0, 0, 11341, + 11342, 7, 19, 0, 0, 11342, 11343, 5, 95, 0, 0, 11343, 11344, 7, 14, 0, + 0, 11344, 11345, 7, 20, 0, 0, 11345, 11346, 7, 6, 0, 0, 11346, 11347, 7, + 9, 0, 0, 11347, 11348, 7, 8, 0, 0, 11348, 11349, 7, 11, 0, 0, 11349, 1522, + 1, 0, 0, 0, 11350, 11351, 7, 7, 0, 0, 11351, 11352, 7, 14, 0, 0, 11352, + 11353, 7, 3, 0, 0, 11353, 11354, 7, 6, 0, 0, 11354, 11355, 7, 2, 0, 0, + 11355, 11356, 7, 11, 0, 0, 11356, 1524, 1, 0, 0, 0, 11357, 11358, 7, 7, + 0, 0, 11358, 11359, 7, 9, 0, 0, 11359, 11360, 7, 0, 0, 0, 11360, 11361, + 7, 3, 0, 0, 11361, 11362, 7, 14, 0, 0, 11362, 11363, 7, 15, 0, 0, 11363, + 1526, 1, 0, 0, 0, 11364, 11365, 7, 7, 0, 0, 11365, 11366, 7, 9, 0, 0, 11366, + 11367, 7, 14, 0, 0, 11367, 11368, 7, 4, 0, 0, 11368, 11369, 7, 8, 0, 0, + 11369, 11370, 7, 1, 0, 0, 11370, 11371, 7, 0, 0, 0, 11371, 11372, 7, 3, + 0, 0, 11372, 11373, 7, 18, 0, 0, 11373, 1528, 1, 0, 0, 0, 11374, 11375, + 7, 7, 0, 0, 11375, 11376, 7, 9, 0, 0, 11376, 11377, 7, 14, 0, 0, 11377, + 11378, 7, 4, 0, 0, 11378, 11379, 7, 8, 0, 0, 11379, 11380, 7, 1, 0, 0, + 11380, 11381, 7, 0, 0, 0, 11381, 11382, 7, 3, 0, 0, 11382, 11383, 7, 18, + 0, 0, 11383, 11384, 5, 95, 0, 0, 11384, 11385, 7, 4, 0, 0, 11385, 11386, + 7, 8, 0, 0, 11386, 11387, 7, 20, 0, 0, 11387, 11388, 7, 18, 0, 0, 11388, + 1530, 1, 0, 0, 0, 11389, 11390, 7, 7, 0, 0, 11390, 11391, 7, 9, 0, 0, 11391, + 11392, 7, 14, 0, 0, 11392, 11393, 7, 4, 0, 0, 11393, 11394, 7, 8, 0, 0, + 11394, 11395, 7, 1, 0, 0, 11395, 11396, 7, 0, 0, 0, 11396, 11397, 7, 3, + 0, 0, 11397, 11398, 7, 18, 0, 0, 11398, 11399, 5, 95, 0, 0, 11399, 11400, + 7, 3, 0, 0, 11400, 11401, 7, 4, 0, 0, 11401, 11402, 7, 20, 0, 0, 11402, + 11403, 7, 9, 0, 0, 11403, 1532, 1, 0, 0, 0, 11404, 11405, 7, 7, 0, 0, 11405, + 11406, 7, 9, 0, 0, 11406, 11407, 7, 14, 0, 0, 11407, 11408, 7, 4, 0, 0, + 11408, 11409, 7, 8, 0, 0, 11409, 11410, 7, 1, 0, 0, 11410, 11411, 7, 7, + 0, 0, 11411, 1534, 1, 0, 0, 0, 11412, 11413, 7, 7, 0, 0, 11413, 11414, + 7, 9, 0, 0, 11414, 11415, 7, 14, 0, 0, 11415, 11416, 7, 3, 0, 0, 11416, + 11417, 7, 9, 0, 0, 11417, 11418, 7, 11, 0, 0, 11418, 1536, 1, 0, 0, 0, + 11419, 11420, 7, 7, 0, 0, 11420, 11421, 7, 9, 0, 0, 11421, 11422, 7, 14, + 0, 0, 11422, 11423, 7, 17, 0, 0, 11423, 11424, 7, 3, 0, 0, 11424, 11425, + 7, 9, 0, 0, 11425, 1538, 1, 0, 0, 0, 11426, 11427, 7, 7, 0, 0, 11427, 11428, + 7, 9, 0, 0, 11428, 11429, 7, 14, 0, 0, 11429, 11430, 7, 17, 0, 0, 11430, + 11431, 7, 3, 0, 0, 11431, 11432, 7, 6, 0, 0, 11432, 11433, 7, 11, 0, 0, + 11433, 11434, 7, 18, 0, 0, 11434, 1540, 1, 0, 0, 0, 11435, 11436, 7, 7, + 0, 0, 11436, 11437, 7, 9, 0, 0, 11437, 11438, 7, 14, 0, 0, 11438, 11439, + 7, 17, 0, 0, 11439, 11440, 7, 3, 0, 0, 11440, 11441, 7, 6, 0, 0, 11441, + 11442, 7, 11, 0, 0, 11442, 11443, 7, 18, 0, 0, 11443, 11444, 7, 0, 0, 0, + 11444, 11445, 7, 1, 0, 0, 11445, 11446, 7, 19, 0, 0, 11446, 11447, 7, 6, + 0, 0, 11447, 11448, 7, 8, 0, 0, 11448, 1542, 1, 0, 0, 0, 11449, 11450, + 7, 7, 0, 0, 11450, 11451, 7, 9, 0, 0, 11451, 11452, 7, 9, 0, 0, 11452, + 11453, 7, 1, 0, 0, 11453, 1544, 1, 0, 0, 0, 11454, 11455, 7, 7, 0, 0, 11455, + 11456, 7, 9, 0, 0, 11456, 11457, 7, 20, 0, 0, 11457, 11458, 7, 9, 0, 0, + 11458, 11459, 7, 14, 0, 0, 11459, 11460, 7, 11, 0, 0, 11460, 1546, 1, 0, + 0, 0, 11461, 11462, 7, 7, 0, 0, 11462, 11463, 7, 9, 0, 0, 11463, 11464, + 7, 20, 0, 0, 11464, 11465, 7, 12, 0, 0, 11465, 1548, 1, 0, 0, 0, 11466, + 11467, 7, 7, 0, 0, 11467, 11468, 7, 9, 0, 0, 11468, 11469, 7, 16, 0, 0, + 11469, 11470, 7, 17, 0, 0, 11470, 11471, 7, 9, 0, 0, 11471, 11472, 7, 8, + 0, 0, 11472, 11473, 7, 14, 0, 0, 11473, 11474, 7, 9, 0, 0, 11474, 1550, + 1, 0, 0, 0, 11475, 11476, 7, 7, 0, 0, 11476, 11477, 7, 9, 0, 0, 11477, + 11478, 7, 16, 0, 0, 11478, 11479, 7, 17, 0, 0, 11479, 11480, 7, 9, 0, 0, + 11480, 11481, 7, 8, 0, 0, 11481, 11482, 7, 14, 0, 0, 11482, 11483, 7, 9, + 0, 0, 11483, 11484, 7, 7, 0, 0, 11484, 1552, 1, 0, 0, 0, 11485, 11486, + 7, 7, 0, 0, 11486, 11487, 7, 9, 0, 0, 11487, 11488, 7, 3, 0, 0, 11488, + 11489, 7, 5, 0, 0, 11489, 11490, 7, 9, 0, 0, 11490, 11491, 7, 3, 0, 0, + 11491, 1554, 1, 0, 0, 0, 11492, 11493, 7, 7, 0, 0, 11493, 11494, 7, 9, + 0, 0, 11494, 11495, 7, 3, 0, 0, 11495, 11496, 7, 5, 0, 0, 11496, 11497, + 7, 6, 0, 0, 11497, 11498, 7, 14, 0, 0, 11498, 11499, 7, 9, 0, 0, 11499, + 1556, 1, 0, 0, 0, 11500, 11501, 7, 7, 0, 0, 11501, 11502, 7, 9, 0, 0, 11502, + 11503, 7, 7, 0, 0, 11503, 11504, 7, 7, 0, 0, 11504, 11505, 7, 6, 0, 0, + 11505, 11506, 7, 4, 0, 0, 11506, 11507, 7, 8, 0, 0, 11507, 1558, 1, 0, + 0, 0, 11508, 11509, 7, 7, 0, 0, 11509, 11510, 7, 9, 0, 0, 11510, 11511, + 7, 7, 0, 0, 11511, 11512, 7, 7, 0, 0, 11512, 11513, 7, 6, 0, 0, 11513, + 11514, 7, 4, 0, 0, 11514, 11515, 7, 8, 0, 0, 11515, 11516, 5, 95, 0, 0, + 11516, 11517, 7, 6, 0, 0, 11517, 11518, 7, 1, 0, 0, 11518, 11519, 7, 20, + 0, 0, 11519, 11520, 7, 9, 0, 0, 11520, 11521, 5, 95, 0, 0, 11521, 11522, + 7, 11, 0, 0, 11522, 11523, 7, 6, 0, 0, 11523, 11524, 7, 19, 0, 0, 11524, + 11525, 7, 9, 0, 0, 11525, 11526, 7, 4, 0, 0, 11526, 11527, 7, 17, 0, 0, + 11527, 11528, 7, 11, 0, 0, 11528, 11529, 5, 95, 0, 0, 11529, 11530, 7, + 19, 0, 0, 11530, 11531, 7, 6, 0, 0, 11531, 11532, 7, 8, 0, 0, 11532, 11533, + 7, 7, 0, 0, 11533, 1560, 1, 0, 0, 0, 11534, 11535, 7, 7, 0, 0, 11535, 11536, + 7, 9, 0, 0, 11536, 11537, 7, 7, 0, 0, 11537, 11538, 7, 7, 0, 0, 11538, + 11539, 7, 6, 0, 0, 11539, 11540, 7, 4, 0, 0, 11540, 11541, 7, 8, 0, 0, + 11541, 11542, 5, 95, 0, 0, 11542, 11543, 7, 2, 0, 0, 11543, 11544, 7, 4, + 0, 0, 11544, 11545, 7, 20, 0, 0, 11545, 11546, 7, 6, 0, 0, 11546, 11547, + 7, 14, 0, 0, 11547, 11548, 7, 18, 0, 0, 11548, 1562, 1, 0, 0, 0, 11549, + 11550, 7, 7, 0, 0, 11550, 11551, 7, 9, 0, 0, 11551, 11552, 7, 7, 0, 0, + 11552, 11553, 7, 7, 0, 0, 11553, 11554, 7, 6, 0, 0, 11554, 11555, 7, 4, + 0, 0, 11555, 11556, 7, 8, 0, 0, 11556, 11557, 5, 95, 0, 0, 11557, 11558, + 7, 17, 0, 0, 11558, 11559, 7, 6, 0, 0, 11559, 11560, 5, 95, 0, 0, 11560, + 11561, 7, 6, 0, 0, 11561, 11562, 7, 1, 0, 0, 11562, 11563, 7, 20, 0, 0, + 11563, 11564, 7, 9, 0, 0, 11564, 11565, 5, 95, 0, 0, 11565, 11566, 7, 11, + 0, 0, 11566, 11567, 7, 6, 0, 0, 11567, 11568, 7, 19, 0, 0, 11568, 11569, + 7, 9, 0, 0, 11569, 11570, 7, 4, 0, 0, 11570, 11571, 7, 17, 0, 0, 11571, + 11572, 7, 11, 0, 0, 11572, 11573, 5, 95, 0, 0, 11573, 11574, 7, 19, 0, + 0, 11574, 11575, 7, 6, 0, 0, 11575, 11576, 7, 8, 0, 0, 11576, 11577, 7, + 7, 0, 0, 11577, 1564, 1, 0, 0, 0, 11578, 11579, 7, 7, 0, 0, 11579, 11580, + 7, 9, 0, 0, 11580, 11581, 7, 11, 0, 0, 11581, 1566, 1, 0, 0, 0, 11582, + 11583, 7, 7, 0, 0, 11583, 11584, 7, 9, 0, 0, 11584, 11585, 7, 11, 0, 0, + 11585, 11586, 7, 7, 0, 0, 11586, 1568, 1, 0, 0, 0, 11587, 11588, 7, 7, + 0, 0, 11588, 11589, 7, 9, 0, 0, 11589, 11590, 7, 11, 0, 0, 11590, 11591, + 7, 17, 0, 0, 11591, 11592, 7, 7, 0, 0, 11592, 11593, 7, 9, 0, 0, 11593, + 11594, 7, 3, 0, 0, 11594, 1570, 1, 0, 0, 0, 11595, 11596, 7, 7, 0, 0, 11596, + 11597, 7, 15, 0, 0, 11597, 11598, 7, 0, 0, 0, 11598, 11599, 7, 3, 0, 0, + 11599, 11600, 7, 9, 0, 0, 11600, 1572, 1, 0, 0, 0, 11601, 11602, 7, 7, + 0, 0, 11602, 11603, 7, 15, 0, 0, 11603, 11604, 7, 0, 0, 0, 11604, 11605, + 7, 3, 0, 0, 11605, 11606, 7, 9, 0, 0, 11606, 11607, 7, 1, 0, 0, 11607, + 1574, 1, 0, 0, 0, 11608, 11609, 7, 7, 0, 0, 11609, 11610, 7, 15, 0, 0, + 11610, 11611, 7, 0, 0, 0, 11611, 11612, 7, 3, 0, 0, 11612, 11613, 7, 9, + 0, 0, 11613, 11614, 7, 7, 0, 0, 11614, 1576, 1, 0, 0, 0, 11615, 11616, + 7, 7, 0, 0, 11616, 11617, 7, 15, 0, 0, 11617, 11618, 7, 0, 0, 0, 11618, + 11619, 7, 3, 0, 0, 11619, 11620, 7, 9, 0, 0, 11620, 11621, 5, 95, 0, 0, + 11621, 11622, 7, 3, 0, 0, 11622, 11623, 7, 9, 0, 0, 11623, 11624, 7, 7, + 0, 0, 11624, 11625, 7, 11, 0, 0, 11625, 11626, 7, 3, 0, 0, 11626, 11627, + 7, 6, 0, 0, 11627, 11628, 7, 14, 0, 0, 11628, 11629, 7, 11, 0, 0, 11629, + 11630, 7, 6, 0, 0, 11630, 11631, 7, 4, 0, 0, 11631, 11632, 7, 8, 0, 0, + 11632, 11633, 7, 7, 0, 0, 11633, 1578, 1, 0, 0, 0, 11634, 11635, 7, 7, + 0, 0, 11635, 11636, 7, 15, 0, 0, 11636, 11637, 7, 4, 0, 0, 11637, 11638, + 7, 13, 0, 0, 11638, 1580, 1, 0, 0, 0, 11639, 11640, 7, 7, 0, 0, 11640, + 11641, 7, 15, 0, 0, 11641, 11642, 7, 4, 0, 0, 11642, 11643, 7, 13, 0, 0, + 11643, 11644, 7, 2, 0, 0, 11644, 11645, 7, 20, 0, 0, 11645, 11646, 7, 0, + 0, 0, 11646, 11647, 7, 8, 0, 0, 11647, 1582, 1, 0, 0, 0, 11648, 11649, + 7, 7, 0, 0, 11649, 11650, 7, 15, 0, 0, 11650, 11651, 7, 4, 0, 0, 11651, + 11652, 7, 13, 0, 0, 11652, 11653, 7, 2, 0, 0, 11653, 11654, 7, 20, 0, 0, + 11654, 11655, 7, 0, 0, 0, 11655, 11656, 7, 8, 0, 0, 11656, 11657, 5, 95, + 0, 0, 11657, 11658, 7, 0, 0, 0, 11658, 11659, 7, 20, 0, 0, 11659, 11660, + 7, 20, 0, 0, 11660, 1584, 1, 0, 0, 0, 11661, 11662, 7, 7, 0, 0, 11662, + 11663, 7, 15, 0, 0, 11663, 11664, 7, 4, 0, 0, 11664, 11665, 7, 13, 0, 0, + 11665, 11666, 7, 2, 0, 0, 11666, 11667, 7, 20, 0, 0, 11667, 11668, 7, 0, + 0, 0, 11668, 11669, 7, 8, 0, 0, 11669, 11670, 5, 95, 0, 0, 11670, 11671, + 7, 11, 0, 0, 11671, 11672, 7, 9, 0, 0, 11672, 11673, 7, 23, 0, 0, 11673, + 11674, 7, 11, 0, 0, 11674, 1586, 1, 0, 0, 0, 11675, 11676, 7, 7, 0, 0, + 11676, 11677, 7, 15, 0, 0, 11677, 11678, 7, 4, 0, 0, 11678, 11679, 7, 13, + 0, 0, 11679, 11680, 7, 2, 0, 0, 11680, 11681, 7, 20, 0, 0, 11681, 11682, + 7, 0, 0, 0, 11682, 11683, 7, 8, 0, 0, 11683, 11684, 5, 95, 0, 0, 11684, + 11685, 7, 23, 0, 0, 11685, 11686, 7, 19, 0, 0, 11686, 11687, 7, 20, 0, + 0, 11687, 1588, 1, 0, 0, 0, 11688, 11689, 7, 7, 0, 0, 11689, 11690, 7, + 15, 0, 0, 11690, 11691, 7, 4, 0, 0, 11691, 11692, 7, 13, 0, 0, 11692, 11693, + 5, 95, 0, 0, 11693, 11694, 7, 6, 0, 0, 11694, 11695, 7, 8, 0, 0, 11695, + 11696, 7, 6, 0, 0, 11696, 11697, 7, 11, 0, 0, 11697, 11698, 7, 6, 0, 0, + 11698, 11699, 7, 0, 0, 0, 11699, 11700, 7, 20, 0, 0, 11700, 11701, 5, 95, + 0, 0, 11701, 11702, 7, 3, 0, 0, 11702, 11703, 7, 4, 0, 0, 11703, 11704, + 7, 13, 0, 0, 11704, 11705, 7, 7, 0, 0, 11705, 1590, 1, 0, 0, 0, 11706, + 11707, 7, 7, 0, 0, 11707, 11708, 7, 6, 0, 0, 11708, 11709, 7, 21, 0, 0, + 11709, 11710, 7, 8, 0, 0, 11710, 11711, 7, 0, 0, 0, 11711, 11712, 7, 11, + 0, 0, 11712, 11713, 7, 17, 0, 0, 11713, 11714, 7, 3, 0, 0, 11714, 11715, + 7, 9, 0, 0, 11715, 1592, 1, 0, 0, 0, 11716, 11717, 7, 7, 0, 0, 11717, 11718, + 7, 6, 0, 0, 11718, 11719, 7, 19, 0, 0, 11719, 11720, 7, 2, 0, 0, 11720, + 11721, 7, 20, 0, 0, 11721, 11722, 7, 9, 0, 0, 11722, 1594, 1, 0, 0, 0, + 11723, 11724, 7, 7, 0, 0, 11724, 11725, 7, 6, 0, 0, 11725, 11726, 7, 19, + 0, 0, 11726, 11727, 7, 17, 0, 0, 11727, 11728, 7, 20, 0, 0, 11728, 11729, + 7, 0, 0, 0, 11729, 11730, 7, 11, 0, 0, 11730, 11731, 7, 9, 0, 0, 11731, + 11732, 7, 1, 0, 0, 11732, 11733, 5, 95, 0, 0, 11733, 11734, 7, 1, 0, 0, + 11734, 11735, 7, 0, 0, 0, 11735, 11736, 7, 11, 0, 0, 11736, 11737, 7, 0, + 0, 0, 11737, 11738, 5, 95, 0, 0, 11738, 11739, 7, 7, 0, 0, 11739, 11740, + 7, 15, 0, 0, 11740, 11741, 7, 0, 0, 0, 11741, 11742, 7, 3, 0, 0, 11742, + 11743, 7, 6, 0, 0, 11743, 11744, 7, 8, 0, 0, 11744, 11745, 7, 21, 0, 0, + 11745, 11746, 5, 95, 0, 0, 11746, 11747, 7, 14, 0, 0, 11747, 11748, 7, + 4, 0, 0, 11748, 11749, 7, 8, 0, 0, 11749, 11750, 7, 7, 0, 0, 11750, 11751, + 7, 17, 0, 0, 11751, 11752, 7, 19, 0, 0, 11752, 11753, 7, 9, 0, 0, 11753, + 11754, 7, 3, 0, 0, 11754, 1596, 1, 0, 0, 0, 11755, 11756, 7, 7, 0, 0, 11756, + 11757, 7, 6, 0, 0, 11757, 11758, 7, 8, 0, 0, 11758, 11759, 7, 21, 0, 0, + 11759, 11760, 7, 20, 0, 0, 11760, 11761, 7, 9, 0, 0, 11761, 11762, 5, 95, + 0, 0, 11762, 11763, 7, 17, 0, 0, 11763, 11764, 7, 7, 0, 0, 11764, 11765, + 7, 9, 0, 0, 11765, 11766, 7, 3, 0, 0, 11766, 1598, 1, 0, 0, 0, 11767, 11768, + 7, 7, 0, 0, 11768, 11769, 7, 6, 0, 0, 11769, 11770, 7, 24, 0, 0, 11770, + 11771, 7, 9, 0, 0, 11771, 1600, 1, 0, 0, 0, 11772, 11773, 7, 7, 0, 0, 11773, + 11774, 7, 6, 0, 0, 11774, 11775, 7, 24, 0, 0, 11775, 11776, 7, 9, 0, 0, + 11776, 11777, 5, 95, 0, 0, 11777, 11778, 7, 20, 0, 0, 11778, 11779, 7, + 6, 0, 0, 11779, 11780, 7, 19, 0, 0, 11780, 11781, 7, 6, 0, 0, 11781, 11782, + 7, 11, 0, 0, 11782, 1602, 1, 0, 0, 0, 11783, 11784, 7, 7, 0, 0, 11784, + 11785, 7, 22, 0, 0, 11785, 11786, 7, 6, 0, 0, 11786, 11787, 7, 2, 0, 0, + 11787, 1604, 1, 0, 0, 0, 11788, 11789, 7, 7, 0, 0, 11789, 11790, 7, 22, + 0, 0, 11790, 11791, 7, 6, 0, 0, 11791, 11792, 7, 2, 0, 0, 11792, 11793, + 5, 95, 0, 0, 11793, 11794, 7, 10, 0, 0, 11794, 11795, 7, 20, 0, 0, 11795, + 11796, 7, 0, 0, 0, 11796, 11797, 7, 8, 0, 0, 11797, 11798, 7, 22, 0, 0, + 11798, 11799, 5, 95, 0, 0, 11799, 11800, 7, 20, 0, 0, 11800, 11801, 7, + 6, 0, 0, 11801, 11802, 7, 8, 0, 0, 11802, 11803, 7, 9, 0, 0, 11803, 11804, + 7, 7, 0, 0, 11804, 1606, 1, 0, 0, 0, 11805, 11806, 7, 7, 0, 0, 11806, 11807, + 7, 22, 0, 0, 11807, 11808, 7, 6, 0, 0, 11808, 11809, 7, 2, 0, 0, 11809, + 11810, 5, 95, 0, 0, 11810, 11811, 7, 10, 0, 0, 11811, 11812, 7, 18, 0, + 0, 11812, 11813, 7, 11, 0, 0, 11813, 11814, 7, 9, 0, 0, 11814, 11815, 5, + 95, 0, 0, 11815, 11816, 7, 4, 0, 0, 11816, 11817, 7, 3, 0, 0, 11817, 11818, + 7, 1, 0, 0, 11818, 11819, 7, 9, 0, 0, 11819, 11820, 7, 3, 0, 0, 11820, + 11821, 5, 95, 0, 0, 11821, 11822, 7, 19, 0, 0, 11822, 11823, 7, 0, 0, 0, + 11823, 11824, 7, 3, 0, 0, 11824, 11825, 7, 22, 0, 0, 11825, 1608, 1, 0, + 0, 0, 11826, 11827, 7, 7, 0, 0, 11827, 11828, 7, 22, 0, 0, 11828, 11829, + 7, 6, 0, 0, 11829, 11830, 7, 2, 0, 0, 11830, 11831, 5, 95, 0, 0, 11831, + 11832, 7, 12, 0, 0, 11832, 11833, 7, 6, 0, 0, 11833, 11834, 7, 20, 0, 0, + 11834, 11835, 7, 9, 0, 0, 11835, 1610, 1, 0, 0, 0, 11836, 11837, 7, 7, + 0, 0, 11837, 11838, 7, 22, 0, 0, 11838, 11839, 7, 6, 0, 0, 11839, 11840, + 7, 2, 0, 0, 11840, 11841, 5, 95, 0, 0, 11841, 11842, 7, 12, 0, 0, 11842, + 11843, 7, 6, 0, 0, 11843, 11844, 7, 20, 0, 0, 11844, 11845, 7, 9, 0, 0, + 11845, 11846, 5, 95, 0, 0, 11846, 11848, 1, 0, 0, 0, 11847, 11849, 3, 2247, + 1123, 0, 11848, 11847, 1, 0, 0, 0, 11849, 11850, 1, 0, 0, 0, 11850, 11848, + 1, 0, 0, 0, 11850, 11851, 1, 0, 0, 0, 11851, 1612, 1, 0, 0, 0, 11852, 11853, + 7, 7, 0, 0, 11853, 11854, 7, 22, 0, 0, 11854, 11855, 7, 6, 0, 0, 11855, + 11856, 7, 2, 0, 0, 11856, 11857, 5, 95, 0, 0, 11857, 11858, 7, 15, 0, 0, + 11858, 11859, 7, 9, 0, 0, 11859, 11860, 7, 0, 0, 0, 11860, 11861, 7, 1, + 0, 0, 11861, 11862, 7, 9, 0, 0, 11862, 11863, 7, 3, 0, 0, 11863, 1614, + 1, 0, 0, 0, 11864, 11865, 7, 7, 0, 0, 11865, 11866, 7, 19, 0, 0, 11866, + 11867, 7, 0, 0, 0, 11867, 11868, 7, 20, 0, 0, 11868, 11869, 7, 20, 0, 0, + 11869, 1616, 1, 0, 0, 0, 11870, 11871, 7, 7, 0, 0, 11871, 11872, 7, 8, + 0, 0, 11872, 11873, 7, 0, 0, 0, 11873, 11874, 7, 2, 0, 0, 11874, 11875, + 7, 2, 0, 0, 11875, 11876, 7, 18, 0, 0, 11876, 1618, 1, 0, 0, 0, 11877, + 11878, 7, 7, 0, 0, 11878, 11879, 7, 8, 0, 0, 11879, 11880, 7, 0, 0, 0, + 11880, 11881, 7, 2, 0, 0, 11881, 11882, 7, 2, 0, 0, 11882, 11883, 7, 18, + 0, 0, 11883, 11884, 5, 95, 0, 0, 11884, 11885, 7, 14, 0, 0, 11885, 11886, + 7, 4, 0, 0, 11886, 11887, 7, 19, 0, 0, 11887, 11888, 7, 2, 0, 0, 11888, + 11889, 7, 3, 0, 0, 11889, 11890, 7, 9, 0, 0, 11890, 11891, 7, 7, 0, 0, + 11891, 11892, 7, 7, 0, 0, 11892, 11893, 7, 6, 0, 0, 11893, 11894, 7, 4, + 0, 0, 11894, 11895, 7, 8, 0, 0, 11895, 1620, 1, 0, 0, 0, 11896, 11897, + 7, 7, 0, 0, 11897, 11898, 7, 4, 0, 0, 11898, 11899, 7, 19, 0, 0, 11899, + 11900, 7, 9, 0, 0, 11900, 1622, 1, 0, 0, 0, 11901, 11902, 7, 7, 0, 0, 11902, + 11903, 7, 4, 0, 0, 11903, 11904, 7, 17, 0, 0, 11904, 11905, 7, 8, 0, 0, + 11905, 11906, 7, 1, 0, 0, 11906, 11907, 7, 9, 0, 0, 11907, 11908, 7, 23, + 0, 0, 11908, 1624, 1, 0, 0, 0, 11909, 11910, 7, 7, 0, 0, 11910, 11911, + 7, 4, 0, 0, 11911, 11912, 7, 17, 0, 0, 11912, 11913, 7, 3, 0, 0, 11913, + 11914, 7, 14, 0, 0, 11914, 11915, 7, 9, 0, 0, 11915, 1626, 1, 0, 0, 0, + 11916, 11917, 7, 7, 0, 0, 11917, 11918, 7, 4, 0, 0, 11918, 11919, 7, 17, + 0, 0, 11919, 11920, 7, 3, 0, 0, 11920, 11921, 7, 14, 0, 0, 11921, 11922, + 7, 9, 0, 0, 11922, 11923, 5, 95, 0, 0, 11923, 11924, 7, 14, 0, 0, 11924, + 11925, 7, 4, 0, 0, 11925, 11926, 7, 19, 0, 0, 11926, 11927, 7, 2, 0, 0, + 11927, 11928, 7, 3, 0, 0, 11928, 11929, 7, 9, 0, 0, 11929, 11930, 7, 7, + 0, 0, 11930, 11931, 7, 7, 0, 0, 11931, 11932, 7, 6, 0, 0, 11932, 11933, + 7, 4, 0, 0, 11933, 11934, 7, 8, 0, 0, 11934, 1628, 1, 0, 0, 0, 11935, 11936, + 7, 7, 0, 0, 11936, 11937, 7, 2, 0, 0, 11937, 11938, 7, 0, 0, 0, 11938, + 11939, 7, 14, 0, 0, 11939, 11940, 7, 9, 0, 0, 11940, 1630, 1, 0, 0, 0, + 11941, 11942, 7, 7, 0, 0, 11942, 11943, 7, 2, 0, 0, 11943, 11944, 7, 0, + 0, 0, 11944, 11945, 7, 3, 0, 0, 11945, 11946, 7, 7, 0, 0, 11946, 11947, + 7, 9, 0, 0, 11947, 1632, 1, 0, 0, 0, 11948, 11949, 7, 7, 0, 0, 11949, 11950, + 7, 2, 0, 0, 11950, 11951, 7, 9, 0, 0, 11951, 11952, 7, 14, 0, 0, 11952, + 11953, 7, 6, 0, 0, 11953, 11954, 7, 12, 0, 0, 11954, 11955, 7, 6, 0, 0, + 11955, 11956, 7, 14, 0, 0, 11956, 11957, 7, 0, 0, 0, 11957, 11958, 7, 11, + 0, 0, 11958, 11959, 7, 6, 0, 0, 11959, 11960, 7, 4, 0, 0, 11960, 11961, + 7, 8, 0, 0, 11961, 1634, 1, 0, 0, 0, 11962, 11963, 7, 7, 0, 0, 11963, 11964, + 7, 2, 0, 0, 11964, 11965, 7, 20, 0, 0, 11965, 11966, 7, 6, 0, 0, 11966, + 11967, 7, 11, 0, 0, 11967, 1636, 1, 0, 0, 0, 11968, 11969, 7, 7, 0, 0, + 11969, 11970, 7, 2, 0, 0, 11970, 11971, 7, 20, 0, 0, 11971, 11972, 7, 6, + 0, 0, 11972, 11973, 7, 11, 0, 0, 11973, 11974, 5, 95, 0, 0, 11974, 11975, + 7, 2, 0, 0, 11975, 11976, 7, 0, 0, 0, 11976, 11977, 7, 3, 0, 0, 11977, + 11978, 7, 11, 0, 0, 11978, 1638, 1, 0, 0, 0, 11979, 11980, 7, 7, 0, 0, + 11980, 11981, 7, 16, 0, 0, 11981, 11982, 7, 20, 0, 0, 11982, 1640, 1, 0, + 0, 0, 11983, 11984, 7, 7, 0, 0, 11984, 11985, 7, 7, 0, 0, 11985, 11986, + 7, 4, 0, 0, 11986, 11987, 5, 95, 0, 0, 11987, 11988, 7, 20, 0, 0, 11988, + 11989, 7, 4, 0, 0, 11989, 11990, 7, 21, 0, 0, 11990, 11991, 7, 6, 0, 0, + 11991, 11992, 7, 8, 0, 0, 11992, 11993, 5, 95, 0, 0, 11993, 11994, 7, 2, + 0, 0, 11994, 11995, 7, 0, 0, 0, 11995, 11996, 7, 21, 0, 0, 11996, 11997, + 7, 9, 0, 0, 11997, 1642, 1, 0, 0, 0, 11998, 11999, 7, 7, 0, 0, 11999, 12000, + 7, 11, 0, 0, 12000, 12001, 7, 0, 0, 0, 12001, 12002, 7, 21, 0, 0, 12002, + 12003, 7, 9, 0, 0, 12003, 1644, 1, 0, 0, 0, 12004, 12005, 7, 7, 0, 0, 12005, + 12006, 7, 11, 0, 0, 12006, 12007, 7, 0, 0, 0, 12007, 12008, 7, 21, 0, 0, + 12008, 12009, 7, 9, 0, 0, 12009, 12010, 7, 7, 0, 0, 12010, 1646, 1, 0, + 0, 0, 12011, 12012, 7, 7, 0, 0, 12012, 12013, 7, 11, 0, 0, 12013, 12014, + 7, 0, 0, 0, 12014, 12015, 7, 21, 0, 0, 12015, 12016, 7, 9, 0, 0, 12016, + 12017, 5, 95, 0, 0, 12017, 12018, 7, 14, 0, 0, 12018, 12019, 7, 4, 0, 0, + 12019, 12020, 7, 2, 0, 0, 12020, 12021, 7, 18, 0, 0, 12021, 12022, 5, 95, + 0, 0, 12022, 12023, 7, 4, 0, 0, 12023, 12024, 7, 2, 0, 0, 12024, 12025, + 7, 11, 0, 0, 12025, 12026, 7, 6, 0, 0, 12026, 12027, 7, 4, 0, 0, 12027, + 12028, 7, 8, 0, 0, 12028, 12029, 7, 7, 0, 0, 12029, 1648, 1, 0, 0, 0, 12030, + 12031, 7, 7, 0, 0, 12031, 12032, 7, 11, 0, 0, 12032, 12033, 7, 0, 0, 0, + 12033, 12034, 7, 21, 0, 0, 12034, 12035, 7, 9, 0, 0, 12035, 12036, 5, 95, + 0, 0, 12036, 12037, 7, 12, 0, 0, 12037, 12038, 7, 6, 0, 0, 12038, 12039, + 7, 20, 0, 0, 12039, 12040, 7, 9, 0, 0, 12040, 12041, 5, 95, 0, 0, 12041, + 12042, 7, 12, 0, 0, 12042, 12043, 7, 4, 0, 0, 12043, 12044, 7, 3, 0, 0, + 12044, 12045, 7, 19, 0, 0, 12045, 12046, 7, 0, 0, 0, 12046, 12047, 7, 11, + 0, 0, 12047, 1650, 1, 0, 0, 0, 12048, 12049, 7, 7, 0, 0, 12049, 12050, + 7, 11, 0, 0, 12050, 12051, 7, 0, 0, 0, 12051, 12052, 7, 8, 0, 0, 12052, + 12053, 7, 1, 0, 0, 12053, 12054, 7, 0, 0, 0, 12054, 12055, 7, 3, 0, 0, + 12055, 12056, 7, 1, 0, 0, 12056, 1652, 1, 0, 0, 0, 12057, 12058, 7, 7, + 0, 0, 12058, 12059, 7, 11, 0, 0, 12059, 12060, 7, 0, 0, 0, 12060, 12061, + 7, 8, 0, 0, 12061, 12062, 7, 1, 0, 0, 12062, 12063, 7, 10, 0, 0, 12063, + 12064, 7, 18, 0, 0, 12064, 1654, 1, 0, 0, 0, 12065, 12066, 7, 7, 0, 0, + 12066, 12067, 7, 11, 0, 0, 12067, 12068, 7, 0, 0, 0, 12068, 12069, 7, 3, + 0, 0, 12069, 12070, 7, 11, 0, 0, 12070, 1656, 1, 0, 0, 0, 12071, 12072, + 7, 7, 0, 0, 12072, 12073, 7, 11, 0, 0, 12073, 12074, 7, 0, 0, 0, 12074, + 12075, 7, 3, 0, 0, 12075, 12076, 7, 11, 0, 0, 12076, 12077, 7, 9, 0, 0, + 12077, 12078, 7, 1, 0, 0, 12078, 1658, 1, 0, 0, 0, 12079, 12080, 7, 7, + 0, 0, 12080, 12081, 7, 11, 0, 0, 12081, 12082, 7, 0, 0, 0, 12082, 12083, + 7, 3, 0, 0, 12083, 12084, 7, 11, 0, 0, 12084, 12085, 7, 7, 0, 0, 12085, + 1660, 1, 0, 0, 0, 12086, 12087, 7, 7, 0, 0, 12087, 12088, 7, 11, 0, 0, + 12088, 12089, 7, 0, 0, 0, 12089, 12090, 7, 3, 0, 0, 12090, 12091, 7, 11, + 0, 0, 12091, 12092, 5, 95, 0, 0, 12092, 12093, 7, 1, 0, 0, 12093, 12094, + 7, 0, 0, 0, 12094, 12095, 7, 11, 0, 0, 12095, 12096, 7, 9, 0, 0, 12096, + 1662, 1, 0, 0, 0, 12097, 12098, 7, 7, 0, 0, 12098, 12099, 7, 11, 0, 0, + 12099, 12100, 7, 0, 0, 0, 12100, 12101, 7, 3, 0, 0, 12101, 12102, 7, 11, + 0, 0, 12102, 12103, 5, 95, 0, 0, 12103, 12104, 7, 11, 0, 0, 12104, 12105, + 7, 6, 0, 0, 12105, 12106, 7, 19, 0, 0, 12106, 12107, 7, 9, 0, 0, 12107, + 12108, 7, 7, 0, 0, 12108, 12109, 7, 11, 0, 0, 12109, 12110, 7, 0, 0, 0, + 12110, 12111, 7, 19, 0, 0, 12111, 12112, 7, 2, 0, 0, 12112, 1664, 1, 0, + 0, 0, 12113, 12114, 7, 7, 0, 0, 12114, 12115, 7, 11, 0, 0, 12115, 12116, + 7, 0, 0, 0, 12116, 12117, 7, 11, 0, 0, 12117, 12118, 7, 9, 0, 0, 12118, + 1666, 1, 0, 0, 0, 12119, 12120, 7, 7, 0, 0, 12120, 12121, 7, 11, 0, 0, + 12121, 12122, 7, 0, 0, 0, 12122, 12123, 7, 11, 0, 0, 12123, 12124, 7, 9, + 0, 0, 12124, 12125, 7, 19, 0, 0, 12125, 12126, 7, 9, 0, 0, 12126, 12127, + 7, 8, 0, 0, 12127, 12128, 7, 11, 0, 0, 12128, 1668, 1, 0, 0, 0, 12129, + 12130, 7, 7, 0, 0, 12130, 12131, 7, 11, 0, 0, 12131, 12132, 7, 0, 0, 0, + 12132, 12133, 7, 11, 0, 0, 12133, 12134, 7, 9, 0, 0, 12134, 12135, 7, 19, + 0, 0, 12135, 12136, 7, 9, 0, 0, 12136, 12137, 7, 8, 0, 0, 12137, 12138, + 7, 11, 0, 0, 12138, 12139, 5, 95, 0, 0, 12139, 12140, 7, 16, 0, 0, 12140, + 12141, 7, 17, 0, 0, 12141, 12142, 7, 9, 0, 0, 12142, 12143, 7, 17, 0, 0, + 12143, 12144, 7, 9, 0, 0, 12144, 12145, 7, 1, 0, 0, 12145, 12146, 5, 95, + 0, 0, 12146, 12147, 7, 11, 0, 0, 12147, 12148, 7, 6, 0, 0, 12148, 12149, + 7, 19, 0, 0, 12149, 12150, 7, 9, 0, 0, 12150, 12151, 7, 4, 0, 0, 12151, + 12152, 7, 17, 0, 0, 12152, 12153, 7, 11, 0, 0, 12153, 12154, 5, 95, 0, + 0, 12154, 12155, 7, 6, 0, 0, 12155, 12156, 7, 8, 0, 0, 12156, 12157, 5, + 95, 0, 0, 12157, 12158, 7, 7, 0, 0, 12158, 12159, 7, 9, 0, 0, 12159, 12160, + 7, 14, 0, 0, 12160, 12161, 7, 4, 0, 0, 12161, 12162, 7, 8, 0, 0, 12162, + 12163, 7, 1, 0, 0, 12163, 12164, 7, 7, 0, 0, 12164, 1670, 1, 0, 0, 0, 12165, + 12166, 7, 7, 0, 0, 12166, 12167, 7, 11, 0, 0, 12167, 12168, 7, 0, 0, 0, + 12168, 12169, 7, 11, 0, 0, 12169, 12170, 7, 9, 0, 0, 12170, 12171, 7, 19, + 0, 0, 12171, 12172, 7, 9, 0, 0, 12172, 12173, 7, 8, 0, 0, 12173, 12174, + 7, 11, 0, 0, 12174, 12175, 5, 95, 0, 0, 12175, 12176, 7, 11, 0, 0, 12176, + 12177, 7, 6, 0, 0, 12177, 12178, 7, 19, 0, 0, 12178, 12179, 7, 9, 0, 0, + 12179, 12180, 7, 4, 0, 0, 12180, 12181, 7, 17, 0, 0, 12181, 12182, 7, 11, + 0, 0, 12182, 12183, 5, 95, 0, 0, 12183, 12184, 7, 6, 0, 0, 12184, 12185, + 7, 8, 0, 0, 12185, 12186, 5, 95, 0, 0, 12186, 12187, 7, 7, 0, 0, 12187, + 12188, 7, 9, 0, 0, 12188, 12189, 7, 14, 0, 0, 12189, 12190, 7, 4, 0, 0, + 12190, 12191, 7, 8, 0, 0, 12191, 12192, 7, 1, 0, 0, 12192, 12193, 7, 7, + 0, 0, 12193, 1672, 1, 0, 0, 0, 12194, 12195, 7, 7, 0, 0, 12195, 12196, + 7, 11, 0, 0, 12196, 12197, 7, 0, 0, 0, 12197, 12198, 7, 11, 0, 0, 12198, + 12199, 7, 6, 0, 0, 12199, 12200, 7, 14, 0, 0, 12200, 1674, 1, 0, 0, 0, + 12201, 12202, 7, 7, 0, 0, 12202, 12203, 7, 11, 0, 0, 12203, 12204, 7, 0, + 0, 0, 12204, 12205, 7, 11, 0, 0, 12205, 12206, 7, 6, 0, 0, 12206, 12207, + 7, 7, 0, 0, 12207, 12208, 7, 11, 0, 0, 12208, 12209, 7, 6, 0, 0, 12209, + 12210, 7, 14, 0, 0, 12210, 12211, 7, 7, 0, 0, 12211, 1676, 1, 0, 0, 0, + 12212, 12213, 7, 7, 0, 0, 12213, 12214, 7, 11, 0, 0, 12214, 12215, 7, 0, + 0, 0, 12215, 12216, 7, 11, 0, 0, 12216, 12217, 7, 7, 0, 0, 12217, 1678, + 1, 0, 0, 0, 12218, 12219, 7, 7, 0, 0, 12219, 12220, 7, 11, 0, 0, 12220, + 12221, 7, 0, 0, 0, 12221, 12222, 7, 11, 0, 0, 12222, 12223, 7, 7, 0, 0, + 12223, 12224, 5, 95, 0, 0, 12224, 12225, 7, 1, 0, 0, 12225, 12226, 7, 0, + 0, 0, 12226, 12227, 7, 11, 0, 0, 12227, 12228, 7, 9, 0, 0, 12228, 1680, + 1, 0, 0, 0, 12229, 12230, 7, 7, 0, 0, 12230, 12231, 7, 11, 0, 0, 12231, + 12232, 7, 0, 0, 0, 12232, 12233, 7, 11, 0, 0, 12233, 12234, 7, 7, 0, 0, + 12234, 12235, 5, 95, 0, 0, 12235, 12236, 7, 7, 0, 0, 12236, 12237, 7, 11, + 0, 0, 12237, 12238, 7, 3, 0, 0, 12238, 12239, 7, 9, 0, 0, 12239, 12240, + 7, 0, 0, 0, 12240, 12241, 7, 19, 0, 0, 12241, 1682, 1, 0, 0, 0, 12242, + 12243, 7, 7, 0, 0, 12243, 12244, 7, 11, 0, 0, 12244, 12245, 7, 0, 0, 0, + 12245, 12246, 7, 11, 0, 0, 12246, 12247, 7, 17, 0, 0, 12247, 12248, 7, + 7, 0, 0, 12248, 1684, 1, 0, 0, 0, 12249, 12250, 7, 7, 0, 0, 12250, 12251, + 7, 11, 0, 0, 12251, 12252, 7, 0, 0, 0, 12252, 12253, 7, 11, 0, 0, 12253, + 12254, 7, 17, 0, 0, 12254, 12255, 7, 7, 0, 0, 12255, 12256, 7, 4, 0, 0, + 12256, 12257, 7, 8, 0, 0, 12257, 12258, 7, 20, 0, 0, 12258, 12259, 7, 18, + 0, 0, 12259, 1686, 1, 0, 0, 0, 12260, 12261, 7, 7, 0, 0, 12261, 12262, + 7, 11, 0, 0, 12262, 12263, 7, 1, 0, 0, 12263, 12264, 7, 9, 0, 0, 12264, + 12265, 7, 5, 0, 0, 12265, 1688, 1, 0, 0, 0, 12266, 12267, 7, 7, 0, 0, 12267, + 12268, 7, 11, 0, 0, 12268, 12269, 7, 1, 0, 0, 12269, 12270, 7, 9, 0, 0, + 12270, 12271, 7, 5, 0, 0, 12271, 12272, 7, 2, 0, 0, 12272, 1690, 1, 0, + 0, 0, 12273, 12274, 7, 7, 0, 0, 12274, 12275, 7, 11, 0, 0, 12275, 12276, + 7, 4, 0, 0, 12276, 12277, 7, 2, 0, 0, 12277, 1692, 1, 0, 0, 0, 12278, 12279, + 7, 7, 0, 0, 12279, 12280, 7, 11, 0, 0, 12280, 12281, 7, 4, 0, 0, 12281, + 12282, 7, 2, 0, 0, 12282, 12283, 7, 20, 0, 0, 12283, 12284, 7, 6, 0, 0, + 12284, 12285, 7, 7, 0, 0, 12285, 12286, 7, 11, 0, 0, 12286, 1694, 1, 0, + 0, 0, 12287, 12288, 7, 7, 0, 0, 12288, 12289, 7, 11, 0, 0, 12289, 12290, + 7, 4, 0, 0, 12290, 12291, 7, 2, 0, 0, 12291, 12292, 7, 2, 0, 0, 12292, + 12293, 7, 9, 0, 0, 12293, 12294, 7, 1, 0, 0, 12294, 1696, 1, 0, 0, 0, 12295, + 12296, 7, 7, 0, 0, 12296, 12297, 7, 11, 0, 0, 12297, 12298, 7, 4, 0, 0, + 12298, 12299, 7, 3, 0, 0, 12299, 12300, 7, 0, 0, 0, 12300, 12301, 7, 21, + 0, 0, 12301, 12302, 7, 9, 0, 0, 12302, 1698, 1, 0, 0, 0, 12303, 12304, + 7, 7, 0, 0, 12304, 12305, 7, 11, 0, 0, 12305, 12306, 7, 4, 0, 0, 12306, + 12307, 7, 3, 0, 0, 12307, 12308, 7, 0, 0, 0, 12308, 12309, 7, 21, 0, 0, + 12309, 12310, 7, 9, 0, 0, 12310, 12311, 5, 95, 0, 0, 12311, 12312, 7, 0, + 0, 0, 12312, 12313, 7, 20, 0, 0, 12313, 12314, 7, 20, 0, 0, 12314, 12315, + 7, 4, 0, 0, 12315, 12316, 7, 13, 0, 0, 12316, 12317, 7, 9, 0, 0, 12317, + 12318, 7, 1, 0, 0, 12318, 12319, 5, 95, 0, 0, 12319, 12320, 7, 20, 0, 0, + 12320, 12321, 7, 4, 0, 0, 12321, 12322, 7, 14, 0, 0, 12322, 12323, 7, 0, + 0, 0, 12323, 12324, 7, 11, 0, 0, 12324, 12325, 7, 6, 0, 0, 12325, 12326, + 7, 4, 0, 0, 12326, 12327, 7, 8, 0, 0, 12327, 12328, 7, 7, 0, 0, 12328, + 1700, 1, 0, 0, 0, 12329, 12330, 7, 7, 0, 0, 12330, 12331, 7, 11, 0, 0, + 12331, 12332, 7, 4, 0, 0, 12332, 12333, 7, 3, 0, 0, 12333, 12334, 7, 0, + 0, 0, 12334, 12335, 7, 21, 0, 0, 12335, 12336, 7, 9, 0, 0, 12336, 12337, + 5, 95, 0, 0, 12337, 12338, 7, 0, 0, 0, 12338, 12339, 7, 13, 0, 0, 12339, + 12340, 7, 7, 0, 0, 12340, 12341, 5, 95, 0, 0, 12341, 12342, 7, 4, 0, 0, + 12342, 12343, 7, 10, 0, 0, 12343, 12344, 7, 25, 0, 0, 12344, 12345, 7, + 9, 0, 0, 12345, 12346, 7, 14, 0, 0, 12346, 12347, 7, 11, 0, 0, 12347, 12348, + 5, 95, 0, 0, 12348, 12349, 7, 0, 0, 0, 12349, 12350, 7, 14, 0, 0, 12350, + 12351, 7, 20, 0, 0, 12351, 1702, 1, 0, 0, 0, 12352, 12353, 7, 7, 0, 0, + 12353, 12354, 7, 11, 0, 0, 12354, 12355, 7, 4, 0, 0, 12355, 12356, 7, 3, + 0, 0, 12356, 12357, 7, 0, 0, 0, 12357, 12358, 7, 21, 0, 0, 12358, 12359, + 7, 9, 0, 0, 12359, 12360, 5, 95, 0, 0, 12360, 12361, 7, 0, 0, 0, 12361, + 12362, 7, 13, 0, 0, 12362, 12363, 7, 7, 0, 0, 12363, 12364, 5, 95, 0, 0, + 12364, 12365, 7, 3, 0, 0, 12365, 12366, 7, 4, 0, 0, 12366, 12367, 7, 20, + 0, 0, 12367, 12368, 7, 9, 0, 0, 12368, 12369, 5, 95, 0, 0, 12369, 12370, + 7, 0, 0, 0, 12370, 12371, 7, 3, 0, 0, 12371, 12372, 7, 8, 0, 0, 12372, + 1704, 1, 0, 0, 0, 12373, 12374, 7, 7, 0, 0, 12374, 12375, 7, 11, 0, 0, + 12375, 12376, 7, 4, 0, 0, 12376, 12377, 7, 3, 0, 0, 12377, 12378, 7, 0, + 0, 0, 12378, 12379, 7, 21, 0, 0, 12379, 12380, 7, 9, 0, 0, 12380, 12381, + 5, 95, 0, 0, 12381, 12382, 7, 10, 0, 0, 12382, 12383, 7, 20, 0, 0, 12383, + 12384, 7, 4, 0, 0, 12384, 12385, 7, 14, 0, 0, 12385, 12386, 7, 22, 0, 0, + 12386, 12387, 7, 9, 0, 0, 12387, 12388, 7, 1, 0, 0, 12388, 12389, 5, 95, + 0, 0, 12389, 12390, 7, 20, 0, 0, 12390, 12391, 7, 4, 0, 0, 12391, 12392, + 7, 14, 0, 0, 12392, 12393, 7, 0, 0, 0, 12393, 12394, 7, 11, 0, 0, 12394, + 12395, 7, 6, 0, 0, 12395, 12396, 7, 4, 0, 0, 12396, 12397, 7, 8, 0, 0, + 12397, 12398, 7, 7, 0, 0, 12398, 1706, 1, 0, 0, 0, 12399, 12400, 7, 7, + 0, 0, 12400, 12401, 7, 11, 0, 0, 12401, 12402, 7, 4, 0, 0, 12402, 12403, + 7, 3, 0, 0, 12403, 12404, 7, 0, 0, 0, 12404, 12405, 7, 21, 0, 0, 12405, + 12406, 7, 9, 0, 0, 12406, 12407, 5, 95, 0, 0, 12407, 12408, 7, 6, 0, 0, + 12408, 12409, 7, 8, 0, 0, 12409, 12410, 7, 11, 0, 0, 12410, 12411, 7, 9, + 0, 0, 12411, 12412, 7, 21, 0, 0, 12412, 12413, 7, 3, 0, 0, 12413, 12414, + 7, 0, 0, 0, 12414, 12415, 7, 11, 0, 0, 12415, 12416, 7, 6, 0, 0, 12416, + 12417, 7, 4, 0, 0, 12417, 12418, 7, 8, 0, 0, 12418, 1708, 1, 0, 0, 0, 12419, + 12420, 7, 7, 0, 0, 12420, 12421, 7, 11, 0, 0, 12421, 12422, 7, 4, 0, 0, + 12422, 12423, 7, 3, 0, 0, 12423, 12424, 7, 0, 0, 0, 12424, 12425, 7, 21, + 0, 0, 12425, 12426, 7, 9, 0, 0, 12426, 12427, 5, 95, 0, 0, 12427, 12428, + 7, 2, 0, 0, 12428, 12429, 7, 3, 0, 0, 12429, 12430, 7, 4, 0, 0, 12430, + 12431, 7, 5, 0, 0, 12431, 12432, 7, 6, 0, 0, 12432, 12433, 7, 1, 0, 0, + 12433, 12434, 7, 9, 0, 0, 12434, 12435, 7, 3, 0, 0, 12435, 1710, 1, 0, + 0, 0, 12436, 12437, 7, 7, 0, 0, 12437, 12438, 7, 11, 0, 0, 12438, 12439, + 7, 3, 0, 0, 12439, 1712, 1, 0, 0, 0, 12440, 12441, 7, 7, 0, 0, 12441, 12442, + 7, 11, 0, 0, 12442, 12443, 7, 3, 0, 0, 12443, 12444, 7, 9, 0, 0, 12444, + 12445, 7, 0, 0, 0, 12445, 12446, 7, 19, 0, 0, 12446, 1714, 1, 0, 0, 0, + 12447, 12448, 7, 7, 0, 0, 12448, 12449, 7, 11, 0, 0, 12449, 12450, 7, 3, + 0, 0, 12450, 12451, 7, 9, 0, 0, 12451, 12452, 7, 0, 0, 0, 12452, 12453, + 7, 19, 0, 0, 12453, 12454, 7, 7, 0, 0, 12454, 1716, 1, 0, 0, 0, 12455, + 12456, 7, 7, 0, 0, 12456, 12457, 7, 11, 0, 0, 12457, 12458, 7, 3, 0, 0, + 12458, 12459, 7, 6, 0, 0, 12459, 12460, 7, 14, 0, 0, 12460, 12461, 7, 11, + 0, 0, 12461, 1718, 1, 0, 0, 0, 12462, 12463, 7, 7, 0, 0, 12463, 12464, + 7, 11, 0, 0, 12464, 12465, 7, 3, 0, 0, 12465, 12466, 7, 6, 0, 0, 12466, + 12467, 7, 14, 0, 0, 12467, 12468, 7, 11, 0, 0, 12468, 12469, 5, 95, 0, + 0, 12469, 12470, 7, 25, 0, 0, 12470, 12471, 7, 7, 0, 0, 12471, 12472, 7, + 4, 0, 0, 12472, 12473, 7, 8, 0, 0, 12473, 12474, 5, 95, 0, 0, 12474, 12475, + 7, 4, 0, 0, 12475, 12476, 7, 17, 0, 0, 12476, 12477, 7, 11, 0, 0, 12477, + 12478, 7, 2, 0, 0, 12478, 12479, 7, 17, 0, 0, 12479, 12480, 7, 11, 0, 0, + 12480, 1720, 1, 0, 0, 0, 12481, 12482, 7, 7, 0, 0, 12482, 12483, 7, 11, + 0, 0, 12483, 12484, 7, 3, 0, 0, 12484, 12485, 7, 6, 0, 0, 12485, 12486, + 7, 8, 0, 0, 12486, 12487, 7, 21, 0, 0, 12487, 12488, 5, 95, 0, 0, 12488, + 12489, 7, 0, 0, 0, 12489, 12490, 7, 21, 0, 0, 12490, 12491, 7, 21, 0, 0, + 12491, 1722, 1, 0, 0, 0, 12492, 12493, 7, 7, 0, 0, 12493, 12494, 7, 11, + 0, 0, 12494, 12495, 7, 3, 0, 0, 12495, 12496, 7, 6, 0, 0, 12496, 12497, + 7, 8, 0, 0, 12497, 12498, 7, 21, 0, 0, 12498, 12499, 5, 95, 0, 0, 12499, + 12500, 7, 9, 0, 0, 12500, 12501, 7, 7, 0, 0, 12501, 12502, 7, 14, 0, 0, + 12502, 12503, 7, 0, 0, 0, 12503, 12504, 7, 2, 0, 0, 12504, 12505, 7, 9, + 0, 0, 12505, 1724, 1, 0, 0, 0, 12506, 12507, 7, 7, 0, 0, 12507, 12508, + 7, 11, 0, 0, 12508, 12509, 7, 3, 0, 0, 12509, 12510, 7, 6, 0, 0, 12510, + 12511, 7, 2, 0, 0, 12511, 12512, 5, 95, 0, 0, 12512, 12513, 7, 8, 0, 0, + 12513, 12514, 7, 17, 0, 0, 12514, 12515, 7, 20, 0, 0, 12515, 12516, 7, + 20, 0, 0, 12516, 12517, 5, 95, 0, 0, 12517, 12518, 7, 5, 0, 0, 12518, 12519, + 7, 0, 0, 0, 12519, 12520, 7, 20, 0, 0, 12520, 12521, 7, 17, 0, 0, 12521, + 12522, 7, 9, 0, 0, 12522, 12523, 7, 7, 0, 0, 12523, 1726, 1, 0, 0, 0, 12524, + 12525, 7, 7, 0, 0, 12525, 12526, 7, 11, 0, 0, 12526, 12527, 7, 3, 0, 0, + 12527, 12528, 7, 6, 0, 0, 12528, 12529, 7, 2, 0, 0, 12529, 12530, 5, 95, + 0, 0, 12530, 12531, 7, 4, 0, 0, 12531, 12532, 7, 17, 0, 0, 12532, 12533, + 7, 11, 0, 0, 12533, 12534, 7, 9, 0, 0, 12534, 12535, 7, 3, 0, 0, 12535, + 12536, 5, 95, 0, 0, 12536, 12537, 7, 0, 0, 0, 12537, 12538, 7, 3, 0, 0, + 12538, 12539, 7, 3, 0, 0, 12539, 12540, 7, 0, 0, 0, 12540, 12541, 7, 18, + 0, 0, 12541, 1728, 1, 0, 0, 0, 12542, 12543, 7, 7, 0, 0, 12543, 12544, + 7, 11, 0, 0, 12544, 12545, 7, 3, 0, 0, 12545, 12546, 7, 6, 0, 0, 12546, + 12547, 7, 2, 0, 0, 12547, 12548, 5, 95, 0, 0, 12548, 12549, 7, 4, 0, 0, + 12549, 12550, 7, 17, 0, 0, 12550, 12551, 7, 11, 0, 0, 12551, 12552, 7, + 9, 0, 0, 12552, 12553, 7, 3, 0, 0, 12553, 12554, 5, 95, 0, 0, 12554, 12555, + 7, 9, 0, 0, 12555, 12556, 7, 20, 0, 0, 12556, 12557, 7, 9, 0, 0, 12557, + 12558, 7, 19, 0, 0, 12558, 12559, 7, 9, 0, 0, 12559, 12560, 7, 8, 0, 0, + 12560, 12561, 7, 11, 0, 0, 12561, 1730, 1, 0, 0, 0, 12562, 12563, 7, 7, + 0, 0, 12563, 12564, 7, 17, 0, 0, 12564, 12565, 7, 10, 0, 0, 12565, 12566, + 7, 7, 0, 0, 12566, 12567, 7, 11, 0, 0, 12567, 12568, 7, 3, 0, 0, 12568, + 1732, 1, 0, 0, 0, 12569, 12570, 7, 7, 0, 0, 12570, 12571, 7, 17, 0, 0, + 12571, 12572, 7, 10, 0, 0, 12572, 12573, 7, 7, 0, 0, 12573, 12574, 7, 11, + 0, 0, 12574, 12575, 7, 3, 0, 0, 12575, 12576, 7, 6, 0, 0, 12576, 12577, + 7, 8, 0, 0, 12577, 12578, 7, 21, 0, 0, 12578, 1734, 1, 0, 0, 0, 12579, + 12580, 7, 7, 0, 0, 12580, 12581, 7, 17, 0, 0, 12581, 12582, 7, 19, 0, 0, + 12582, 1736, 1, 0, 0, 0, 12583, 12584, 7, 7, 0, 0, 12584, 12585, 7, 17, + 0, 0, 12585, 12586, 7, 2, 0, 0, 12586, 12587, 7, 2, 0, 0, 12587, 12588, + 7, 4, 0, 0, 12588, 12589, 7, 3, 0, 0, 12589, 12590, 7, 11, 0, 0, 12590, + 12591, 7, 9, 0, 0, 12591, 12592, 7, 1, 0, 0, 12592, 1738, 1, 0, 0, 0, 12593, + 12594, 7, 7, 0, 0, 12594, 12595, 7, 17, 0, 0, 12595, 12596, 7, 7, 0, 0, + 12596, 12597, 7, 2, 0, 0, 12597, 12598, 7, 9, 0, 0, 12598, 12599, 7, 8, + 0, 0, 12599, 12600, 7, 1, 0, 0, 12600, 1740, 1, 0, 0, 0, 12601, 12602, + 7, 7, 0, 0, 12602, 12603, 7, 17, 0, 0, 12603, 12604, 7, 7, 0, 0, 12604, + 12605, 7, 2, 0, 0, 12605, 12606, 7, 9, 0, 0, 12606, 12607, 7, 8, 0, 0, + 12607, 12608, 7, 1, 0, 0, 12608, 12609, 7, 9, 0, 0, 12609, 12610, 7, 1, + 0, 0, 12610, 1742, 1, 0, 0, 0, 12611, 12612, 7, 7, 0, 0, 12612, 12613, + 7, 17, 0, 0, 12613, 12614, 7, 7, 0, 0, 12614, 12615, 7, 2, 0, 0, 12615, + 12616, 7, 9, 0, 0, 12616, 12617, 7, 8, 0, 0, 12617, 12618, 7, 1, 0, 0, + 12618, 12619, 5, 95, 0, 0, 12619, 12620, 7, 6, 0, 0, 12620, 12621, 7, 19, + 0, 0, 12621, 12622, 7, 19, 0, 0, 12622, 12623, 7, 9, 0, 0, 12623, 12624, + 7, 1, 0, 0, 12624, 12625, 7, 6, 0, 0, 12625, 12626, 7, 0, 0, 0, 12626, + 12627, 7, 11, 0, 0, 12627, 12628, 7, 9, 0, 0, 12628, 1744, 1, 0, 0, 0, + 12629, 12630, 7, 7, 0, 0, 12630, 12631, 7, 17, 0, 0, 12631, 12632, 7, 7, + 0, 0, 12632, 12633, 7, 2, 0, 0, 12633, 12634, 7, 9, 0, 0, 12634, 12635, + 7, 8, 0, 0, 12635, 12636, 7, 1, 0, 0, 12636, 12637, 5, 95, 0, 0, 12637, + 12638, 7, 11, 0, 0, 12638, 12639, 7, 0, 0, 0, 12639, 12640, 7, 7, 0, 0, + 12640, 12641, 7, 22, 0, 0, 12641, 12642, 5, 95, 0, 0, 12642, 12643, 7, + 0, 0, 0, 12643, 12644, 7, 12, 0, 0, 12644, 12645, 7, 11, 0, 0, 12645, 12646, + 7, 9, 0, 0, 12646, 12647, 7, 3, 0, 0, 12647, 12648, 5, 95, 0, 0, 12648, + 12649, 7, 8, 0, 0, 12649, 12650, 7, 17, 0, 0, 12650, 12651, 7, 19, 0, 0, + 12651, 12652, 5, 95, 0, 0, 12652, 12653, 7, 12, 0, 0, 12653, 12654, 7, + 0, 0, 0, 12654, 12655, 7, 6, 0, 0, 12655, 12656, 7, 20, 0, 0, 12656, 12657, + 7, 17, 0, 0, 12657, 12658, 7, 3, 0, 0, 12658, 12659, 7, 9, 0, 0, 12659, + 12660, 7, 7, 0, 0, 12660, 1746, 1, 0, 0, 0, 12661, 12662, 7, 7, 0, 0, 12662, + 12663, 7, 13, 0, 0, 12663, 12664, 7, 0, 0, 0, 12664, 12665, 7, 2, 0, 0, + 12665, 1748, 1, 0, 0, 0, 12666, 12667, 7, 7, 0, 0, 12667, 12668, 7, 13, + 0, 0, 12668, 12669, 7, 6, 0, 0, 12669, 12670, 7, 11, 0, 0, 12670, 12671, + 7, 14, 0, 0, 12671, 12672, 7, 15, 0, 0, 12672, 1750, 1, 0, 0, 0, 12673, + 12674, 7, 7, 0, 0, 12674, 12675, 7, 18, 0, 0, 12675, 12676, 7, 8, 0, 0, + 12676, 12677, 7, 14, 0, 0, 12677, 12678, 5, 95, 0, 0, 12678, 12679, 7, + 2, 0, 0, 12679, 12680, 7, 0, 0, 0, 12680, 12681, 7, 7, 0, 0, 12681, 12682, + 7, 7, 0, 0, 12682, 12683, 7, 13, 0, 0, 12683, 12684, 7, 4, 0, 0, 12684, + 12685, 7, 3, 0, 0, 12685, 12686, 7, 1, 0, 0, 12686, 1752, 1, 0, 0, 0, 12687, + 12688, 7, 7, 0, 0, 12688, 12689, 7, 18, 0, 0, 12689, 12690, 7, 7, 0, 0, + 12690, 12691, 7, 0, 0, 0, 12691, 12692, 7, 1, 0, 0, 12692, 12693, 7, 19, + 0, 0, 12693, 12694, 7, 6, 0, 0, 12694, 12695, 7, 8, 0, 0, 12695, 1754, + 1, 0, 0, 0, 12696, 12697, 7, 7, 0, 0, 12697, 12698, 7, 18, 0, 0, 12698, + 12699, 7, 7, 0, 0, 12699, 12700, 7, 11, 0, 0, 12700, 12701, 7, 9, 0, 0, + 12701, 12702, 7, 19, 0, 0, 12702, 1756, 1, 0, 0, 0, 12703, 12704, 7, 7, + 0, 0, 12704, 12705, 7, 18, 0, 0, 12705, 12706, 7, 7, 0, 0, 12706, 12707, + 7, 11, 0, 0, 12707, 12708, 7, 9, 0, 0, 12708, 12709, 7, 19, 0, 0, 12709, + 12710, 5, 95, 0, 0, 12710, 12711, 7, 17, 0, 0, 12711, 12712, 7, 7, 0, 0, + 12712, 12713, 7, 9, 0, 0, 12713, 12714, 7, 3, 0, 0, 12714, 1758, 1, 0, + 0, 0, 12715, 12716, 7, 11, 0, 0, 12716, 12717, 7, 0, 0, 0, 12717, 12718, + 7, 10, 0, 0, 12718, 12719, 7, 20, 0, 0, 12719, 12720, 7, 9, 0, 0, 12720, + 1760, 1, 0, 0, 0, 12721, 12722, 7, 11, 0, 0, 12722, 12723, 7, 0, 0, 0, + 12723, 12724, 7, 10, 0, 0, 12724, 12725, 7, 20, 0, 0, 12725, 12726, 7, + 9, 0, 0, 12726, 12727, 7, 0, 0, 0, 12727, 12728, 7, 17, 0, 0, 12728, 12729, + 5, 95, 0, 0, 12729, 12730, 7, 1, 0, 0, 12730, 12731, 7, 9, 0, 0, 12731, + 12732, 7, 7, 0, 0, 12732, 12733, 7, 22, 0, 0, 12733, 12734, 7, 11, 0, 0, + 12734, 12735, 7, 4, 0, 0, 12735, 12736, 7, 2, 0, 0, 12736, 1762, 1, 0, + 0, 0, 12737, 12738, 7, 11, 0, 0, 12738, 12739, 7, 0, 0, 0, 12739, 12740, + 7, 10, 0, 0, 12740, 12741, 7, 20, 0, 0, 12741, 12742, 7, 9, 0, 0, 12742, + 12743, 7, 0, 0, 0, 12743, 12744, 7, 17, 0, 0, 12744, 12745, 5, 95, 0, 0, + 12745, 12746, 7, 7, 0, 0, 12746, 12747, 7, 9, 0, 0, 12747, 12748, 7, 3, + 0, 0, 12748, 12749, 7, 5, 0, 0, 12749, 12750, 7, 9, 0, 0, 12750, 12751, + 7, 3, 0, 0, 12751, 1764, 1, 0, 0, 0, 12752, 12753, 7, 11, 0, 0, 12753, + 12754, 7, 0, 0, 0, 12754, 12755, 7, 10, 0, 0, 12755, 12756, 7, 20, 0, 0, + 12756, 12757, 7, 9, 0, 0, 12757, 12758, 7, 7, 0, 0, 12758, 1766, 1, 0, + 0, 0, 12759, 12760, 7, 11, 0, 0, 12760, 12761, 7, 0, 0, 0, 12761, 12762, + 7, 10, 0, 0, 12762, 12763, 7, 20, 0, 0, 12763, 12764, 7, 9, 0, 0, 12764, + 12765, 7, 7, 0, 0, 12765, 12766, 7, 0, 0, 0, 12766, 12767, 7, 19, 0, 0, + 12767, 12768, 7, 2, 0, 0, 12768, 12769, 7, 20, 0, 0, 12769, 12770, 7, 9, + 0, 0, 12770, 1768, 1, 0, 0, 0, 12771, 12772, 7, 11, 0, 0, 12772, 12773, + 7, 0, 0, 0, 12773, 12774, 7, 10, 0, 0, 12774, 12775, 7, 20, 0, 0, 12775, + 12776, 7, 9, 0, 0, 12776, 12777, 5, 95, 0, 0, 12777, 12778, 7, 12, 0, 0, + 12778, 12779, 7, 4, 0, 0, 12779, 12780, 7, 3, 0, 0, 12780, 12781, 7, 19, + 0, 0, 12781, 12782, 7, 0, 0, 0, 12782, 12783, 7, 11, 0, 0, 12783, 1770, + 1, 0, 0, 0, 12784, 12785, 7, 11, 0, 0, 12785, 12786, 7, 0, 0, 0, 12786, + 12787, 7, 10, 0, 0, 12787, 12788, 7, 17, 0, 0, 12788, 12789, 7, 20, 0, + 0, 12789, 12790, 7, 0, 0, 0, 12790, 12791, 7, 3, 0, 0, 12791, 1772, 1, + 0, 0, 0, 12792, 12793, 7, 11, 0, 0, 12793, 12794, 7, 0, 0, 0, 12794, 12795, + 7, 21, 0, 0, 12795, 1774, 1, 0, 0, 0, 12796, 12797, 7, 11, 0, 0, 12797, + 12798, 7, 0, 0, 0, 12798, 12799, 7, 21, 0, 0, 12799, 12800, 7, 7, 0, 0, + 12800, 1776, 1, 0, 0, 0, 12801, 12802, 7, 11, 0, 0, 12802, 12803, 7, 0, + 0, 0, 12803, 12804, 7, 3, 0, 0, 12804, 12805, 7, 21, 0, 0, 12805, 12806, + 7, 9, 0, 0, 12806, 12807, 7, 11, 0, 0, 12807, 1778, 1, 0, 0, 0, 12808, + 12809, 7, 11, 0, 0, 12809, 12810, 7, 0, 0, 0, 12810, 12811, 7, 3, 0, 0, + 12811, 12812, 7, 21, 0, 0, 12812, 12813, 7, 9, 0, 0, 12813, 12814, 7, 11, + 0, 0, 12814, 12815, 5, 95, 0, 0, 12815, 12816, 7, 20, 0, 0, 12816, 12817, + 7, 0, 0, 0, 12817, 12818, 7, 21, 0, 0, 12818, 1780, 1, 0, 0, 0, 12819, + 12820, 7, 11, 0, 0, 12820, 12821, 7, 0, 0, 0, 12821, 12822, 7, 7, 0, 0, + 12822, 12823, 7, 22, 0, 0, 12823, 1782, 1, 0, 0, 0, 12824, 12825, 7, 11, + 0, 0, 12825, 12826, 7, 0, 0, 0, 12826, 12827, 7, 7, 0, 0, 12827, 12828, + 7, 22, 0, 0, 12828, 12829, 7, 7, 0, 0, 12829, 1784, 1, 0, 0, 0, 12830, + 12831, 7, 11, 0, 0, 12831, 12832, 7, 9, 0, 0, 12832, 12833, 7, 19, 0, 0, + 12833, 12834, 7, 2, 0, 0, 12834, 1786, 1, 0, 0, 0, 12835, 12836, 7, 11, + 0, 0, 12836, 12837, 7, 9, 0, 0, 12837, 12838, 7, 19, 0, 0, 12838, 12839, + 7, 2, 0, 0, 12839, 12840, 7, 4, 0, 0, 12840, 12841, 7, 3, 0, 0, 12841, + 12842, 7, 0, 0, 0, 12842, 12843, 7, 3, 0, 0, 12843, 12844, 7, 18, 0, 0, + 12844, 1788, 1, 0, 0, 0, 12845, 12846, 7, 11, 0, 0, 12846, 12847, 7, 9, + 0, 0, 12847, 12848, 7, 3, 0, 0, 12848, 12849, 7, 7, 0, 0, 12849, 12850, + 7, 9, 0, 0, 12850, 1790, 1, 0, 0, 0, 12851, 12852, 7, 11, 0, 0, 12852, + 12853, 7, 9, 0, 0, 12853, 12854, 7, 23, 0, 0, 12854, 12855, 7, 11, 0, 0, + 12855, 12856, 7, 7, 0, 0, 12856, 12857, 7, 6, 0, 0, 12857, 12858, 7, 24, + 0, 0, 12858, 12859, 7, 9, 0, 0, 12859, 1792, 1, 0, 0, 0, 12860, 12861, + 7, 11, 0, 0, 12861, 12862, 7, 15, 0, 0, 12862, 12863, 7, 9, 0, 0, 12863, + 12864, 7, 8, 0, 0, 12864, 1794, 1, 0, 0, 0, 12865, 12866, 7, 11, 0, 0, + 12866, 12867, 7, 6, 0, 0, 12867, 12868, 7, 9, 0, 0, 12868, 12869, 7, 7, + 0, 0, 12869, 1796, 1, 0, 0, 0, 12870, 12871, 7, 11, 0, 0, 12871, 12872, + 7, 6, 0, 0, 12872, 12873, 7, 19, 0, 0, 12873, 12874, 7, 9, 0, 0, 12874, + 1798, 1, 0, 0, 0, 12875, 12876, 7, 11, 0, 0, 12876, 12877, 7, 6, 0, 0, + 12877, 12878, 7, 19, 0, 0, 12878, 12879, 7, 9, 0, 0, 12879, 12880, 7, 0, + 0, 0, 12880, 12881, 7, 1, 0, 0, 12881, 12882, 7, 1, 0, 0, 12882, 1800, + 1, 0, 0, 0, 12883, 12884, 7, 11, 0, 0, 12884, 12885, 7, 6, 0, 0, 12885, + 12886, 7, 19, 0, 0, 12886, 12887, 7, 9, 0, 0, 12887, 12888, 7, 1, 0, 0, + 12888, 12889, 7, 6, 0, 0, 12889, 12890, 7, 12, 0, 0, 12890, 12891, 7, 12, + 0, 0, 12891, 1802, 1, 0, 0, 0, 12892, 12893, 7, 11, 0, 0, 12893, 12894, + 7, 6, 0, 0, 12894, 12895, 7, 19, 0, 0, 12895, 12896, 7, 9, 0, 0, 12896, + 12897, 7, 4, 0, 0, 12897, 12898, 7, 17, 0, 0, 12898, 12899, 7, 11, 0, 0, + 12899, 1804, 1, 0, 0, 0, 12900, 12901, 7, 11, 0, 0, 12901, 12902, 7, 6, + 0, 0, 12902, 12903, 7, 19, 0, 0, 12903, 12904, 7, 9, 0, 0, 12904, 12905, + 7, 3, 0, 0, 12905, 1806, 1, 0, 0, 0, 12906, 12907, 7, 11, 0, 0, 12907, + 12908, 7, 6, 0, 0, 12908, 12909, 7, 19, 0, 0, 12909, 12910, 7, 9, 0, 0, + 12910, 12911, 7, 7, 0, 0, 12911, 12912, 7, 11, 0, 0, 12912, 12913, 7, 0, + 0, 0, 12913, 12914, 7, 19, 0, 0, 12914, 12915, 7, 2, 0, 0, 12915, 1808, + 1, 0, 0, 0, 12916, 12917, 7, 11, 0, 0, 12917, 12918, 7, 6, 0, 0, 12918, + 12919, 7, 19, 0, 0, 12919, 12920, 7, 9, 0, 0, 12920, 12921, 7, 7, 0, 0, + 12921, 12922, 7, 11, 0, 0, 12922, 12923, 7, 0, 0, 0, 12923, 12924, 7, 19, + 0, 0, 12924, 12925, 7, 2, 0, 0, 12925, 12926, 5, 95, 0, 0, 12926, 12927, + 7, 1, 0, 0, 12927, 12928, 7, 0, 0, 0, 12928, 12929, 7, 18, 0, 0, 12929, + 12930, 5, 95, 0, 0, 12930, 12931, 7, 6, 0, 0, 12931, 12932, 7, 7, 0, 0, + 12932, 12933, 5, 95, 0, 0, 12933, 12934, 7, 0, 0, 0, 12934, 12935, 7, 20, + 0, 0, 12935, 12936, 7, 13, 0, 0, 12936, 12937, 7, 0, 0, 0, 12937, 12938, + 7, 18, 0, 0, 12938, 12939, 7, 7, 0, 0, 12939, 12940, 5, 95, 0, 0, 12940, + 12941, 5, 50, 0, 0, 12941, 12942, 5, 52, 0, 0, 12942, 12943, 7, 15, 0, + 0, 12943, 1810, 1, 0, 0, 0, 12944, 12945, 7, 11, 0, 0, 12945, 12946, 7, + 6, 0, 0, 12946, 12947, 7, 19, 0, 0, 12947, 12948, 7, 9, 0, 0, 12948, 12949, + 7, 7, 0, 0, 12949, 12950, 7, 11, 0, 0, 12950, 12951, 7, 0, 0, 0, 12951, + 12952, 7, 19, 0, 0, 12952, 12953, 7, 2, 0, 0, 12953, 12954, 5, 95, 0, 0, + 12954, 12955, 7, 12, 0, 0, 12955, 12956, 7, 4, 0, 0, 12956, 12957, 7, 3, + 0, 0, 12957, 12958, 7, 19, 0, 0, 12958, 12959, 7, 0, 0, 0, 12959, 12960, + 7, 11, 0, 0, 12960, 1812, 1, 0, 0, 0, 12961, 12962, 7, 11, 0, 0, 12962, + 12963, 7, 6, 0, 0, 12963, 12964, 7, 19, 0, 0, 12964, 12965, 7, 9, 0, 0, + 12965, 12966, 7, 7, 0, 0, 12966, 12967, 7, 11, 0, 0, 12967, 12968, 7, 0, + 0, 0, 12968, 12969, 7, 19, 0, 0, 12969, 12970, 7, 2, 0, 0, 12970, 12971, + 5, 95, 0, 0, 12971, 12972, 7, 6, 0, 0, 12972, 12973, 7, 8, 0, 0, 12973, + 12974, 7, 2, 0, 0, 12974, 12975, 7, 17, 0, 0, 12975, 12976, 7, 11, 0, 0, + 12976, 12977, 5, 95, 0, 0, 12977, 12978, 7, 12, 0, 0, 12978, 12979, 7, + 4, 0, 0, 12979, 12980, 7, 3, 0, 0, 12980, 12981, 7, 19, 0, 0, 12981, 12982, + 7, 0, 0, 0, 12982, 12983, 7, 11, 0, 0, 12983, 1814, 1, 0, 0, 0, 12984, + 12985, 7, 11, 0, 0, 12985, 12986, 7, 6, 0, 0, 12986, 12987, 7, 19, 0, 0, + 12987, 12988, 7, 9, 0, 0, 12988, 12989, 7, 7, 0, 0, 12989, 12990, 7, 11, + 0, 0, 12990, 12991, 7, 0, 0, 0, 12991, 12992, 7, 19, 0, 0, 12992, 12993, + 7, 2, 0, 0, 12993, 12994, 5, 95, 0, 0, 12994, 12995, 7, 20, 0, 0, 12995, + 12996, 7, 11, 0, 0, 12996, 12997, 7, 24, 0, 0, 12997, 1816, 1, 0, 0, 0, + 12998, 12999, 7, 11, 0, 0, 12999, 13000, 7, 6, 0, 0, 13000, 13001, 7, 19, + 0, 0, 13001, 13002, 7, 9, 0, 0, 13002, 13003, 7, 7, 0, 0, 13003, 13004, + 7, 11, 0, 0, 13004, 13005, 7, 0, 0, 0, 13005, 13006, 7, 19, 0, 0, 13006, + 13007, 7, 2, 0, 0, 13007, 13008, 5, 95, 0, 0, 13008, 13009, 7, 20, 0, 0, + 13009, 13010, 7, 11, 0, 0, 13010, 13011, 7, 24, 0, 0, 13011, 13012, 5, + 95, 0, 0, 13012, 13013, 7, 4, 0, 0, 13013, 13014, 7, 17, 0, 0, 13014, 13015, + 7, 11, 0, 0, 13015, 13016, 7, 2, 0, 0, 13016, 13017, 7, 17, 0, 0, 13017, + 13018, 7, 11, 0, 0, 13018, 13019, 5, 95, 0, 0, 13019, 13020, 7, 12, 0, + 0, 13020, 13021, 7, 4, 0, 0, 13021, 13022, 7, 3, 0, 0, 13022, 13023, 7, + 19, 0, 0, 13023, 13024, 7, 0, 0, 0, 13024, 13025, 7, 11, 0, 0, 13025, 1818, + 1, 0, 0, 0, 13026, 13027, 7, 11, 0, 0, 13027, 13028, 7, 6, 0, 0, 13028, + 13029, 7, 19, 0, 0, 13029, 13030, 7, 9, 0, 0, 13030, 13031, 7, 7, 0, 0, + 13031, 13032, 7, 11, 0, 0, 13032, 13033, 7, 0, 0, 0, 13033, 13034, 7, 19, + 0, 0, 13034, 13035, 7, 2, 0, 0, 13035, 13036, 5, 95, 0, 0, 13036, 13037, + 7, 8, 0, 0, 13037, 13038, 7, 11, 0, 0, 13038, 13039, 7, 24, 0, 0, 13039, + 1820, 1, 0, 0, 0, 13040, 13041, 7, 11, 0, 0, 13041, 13042, 7, 6, 0, 0, + 13042, 13043, 7, 19, 0, 0, 13043, 13044, 7, 9, 0, 0, 13044, 13045, 7, 7, + 0, 0, 13045, 13046, 7, 11, 0, 0, 13046, 13047, 7, 0, 0, 0, 13047, 13048, + 7, 19, 0, 0, 13048, 13049, 7, 2, 0, 0, 13049, 13050, 5, 95, 0, 0, 13050, + 13051, 7, 8, 0, 0, 13051, 13052, 7, 11, 0, 0, 13052, 13053, 7, 24, 0, 0, + 13053, 13054, 5, 95, 0, 0, 13054, 13055, 7, 4, 0, 0, 13055, 13056, 7, 17, + 0, 0, 13056, 13057, 7, 11, 0, 0, 13057, 13058, 7, 2, 0, 0, 13058, 13059, + 7, 17, 0, 0, 13059, 13060, 7, 11, 0, 0, 13060, 13061, 5, 95, 0, 0, 13061, + 13062, 7, 12, 0, 0, 13062, 13063, 7, 4, 0, 0, 13063, 13064, 7, 3, 0, 0, + 13064, 13065, 7, 19, 0, 0, 13065, 13066, 7, 0, 0, 0, 13066, 13067, 7, 11, + 0, 0, 13067, 1822, 1, 0, 0, 0, 13068, 13069, 7, 11, 0, 0, 13069, 13070, + 7, 6, 0, 0, 13070, 13071, 7, 19, 0, 0, 13071, 13072, 7, 9, 0, 0, 13072, + 13073, 7, 7, 0, 0, 13073, 13074, 7, 11, 0, 0, 13074, 13075, 7, 0, 0, 0, + 13075, 13076, 7, 19, 0, 0, 13076, 13077, 7, 2, 0, 0, 13077, 13078, 5, 95, + 0, 0, 13078, 13079, 7, 4, 0, 0, 13079, 13080, 7, 17, 0, 0, 13080, 13081, + 7, 11, 0, 0, 13081, 13082, 7, 2, 0, 0, 13082, 13083, 7, 17, 0, 0, 13083, + 13084, 7, 11, 0, 0, 13084, 13085, 5, 95, 0, 0, 13085, 13086, 7, 12, 0, + 0, 13086, 13087, 7, 4, 0, 0, 13087, 13088, 7, 3, 0, 0, 13088, 13089, 7, + 19, 0, 0, 13089, 13090, 7, 0, 0, 0, 13090, 13091, 7, 11, 0, 0, 13091, 1824, + 1, 0, 0, 0, 13092, 13093, 7, 11, 0, 0, 13093, 13094, 7, 6, 0, 0, 13094, + 13095, 7, 19, 0, 0, 13095, 13096, 7, 9, 0, 0, 13096, 13097, 7, 7, 0, 0, + 13097, 13098, 7, 11, 0, 0, 13098, 13099, 7, 0, 0, 0, 13099, 13100, 7, 19, + 0, 0, 13100, 13101, 7, 2, 0, 0, 13101, 13102, 5, 95, 0, 0, 13102, 13103, + 7, 11, 0, 0, 13103, 13104, 7, 18, 0, 0, 13104, 13105, 7, 2, 0, 0, 13105, + 13106, 7, 9, 0, 0, 13106, 13107, 5, 95, 0, 0, 13107, 13108, 7, 19, 0, 0, + 13108, 13109, 7, 0, 0, 0, 13109, 13110, 7, 2, 0, 0, 13110, 13111, 7, 2, + 0, 0, 13111, 13112, 7, 6, 0, 0, 13112, 13113, 7, 8, 0, 0, 13113, 13114, + 7, 21, 0, 0, 13114, 1826, 1, 0, 0, 0, 13115, 13116, 7, 11, 0, 0, 13116, + 13117, 7, 6, 0, 0, 13117, 13118, 7, 19, 0, 0, 13118, 13119, 7, 9, 0, 0, + 13119, 13120, 7, 7, 0, 0, 13120, 13121, 7, 11, 0, 0, 13121, 13122, 7, 0, + 0, 0, 13122, 13123, 7, 19, 0, 0, 13123, 13124, 7, 2, 0, 0, 13124, 13125, + 5, 95, 0, 0, 13125, 13126, 7, 11, 0, 0, 13126, 13127, 7, 24, 0, 0, 13127, + 1828, 1, 0, 0, 0, 13128, 13129, 7, 11, 0, 0, 13129, 13130, 7, 6, 0, 0, + 13130, 13131, 7, 19, 0, 0, 13131, 13132, 7, 9, 0, 0, 13132, 13133, 7, 7, + 0, 0, 13133, 13134, 7, 11, 0, 0, 13134, 13135, 7, 0, 0, 0, 13135, 13136, + 7, 19, 0, 0, 13136, 13137, 7, 2, 0, 0, 13137, 13138, 5, 95, 0, 0, 13138, + 13139, 7, 11, 0, 0, 13139, 13140, 7, 24, 0, 0, 13140, 13141, 5, 95, 0, + 0, 13141, 13142, 7, 4, 0, 0, 13142, 13143, 7, 17, 0, 0, 13143, 13144, 7, + 11, 0, 0, 13144, 13145, 7, 2, 0, 0, 13145, 13146, 7, 17, 0, 0, 13146, 13147, + 7, 11, 0, 0, 13147, 13148, 5, 95, 0, 0, 13148, 13149, 7, 12, 0, 0, 13149, + 13150, 7, 4, 0, 0, 13150, 13151, 7, 3, 0, 0, 13151, 13152, 7, 19, 0, 0, + 13152, 13153, 7, 0, 0, 0, 13153, 13154, 7, 11, 0, 0, 13154, 1830, 1, 0, + 0, 0, 13155, 13156, 7, 11, 0, 0, 13156, 13157, 7, 6, 0, 0, 13157, 13158, + 7, 19, 0, 0, 13158, 13159, 7, 9, 0, 0, 13159, 13160, 7, 7, 0, 0, 13160, + 13161, 7, 11, 0, 0, 13161, 13162, 7, 0, 0, 0, 13162, 13163, 7, 19, 0, 0, + 13163, 13164, 7, 2, 0, 0, 13164, 13165, 7, 0, 0, 0, 13165, 13166, 7, 1, + 0, 0, 13166, 13167, 7, 1, 0, 0, 13167, 1832, 1, 0, 0, 0, 13168, 13169, + 7, 11, 0, 0, 13169, 13170, 7, 6, 0, 0, 13170, 13171, 7, 19, 0, 0, 13171, + 13172, 7, 9, 0, 0, 13172, 13173, 7, 7, 0, 0, 13173, 13174, 7, 11, 0, 0, + 13174, 13175, 7, 0, 0, 0, 13175, 13176, 7, 19, 0, 0, 13176, 13177, 7, 2, + 0, 0, 13177, 13178, 7, 1, 0, 0, 13178, 13179, 7, 6, 0, 0, 13179, 13180, + 7, 12, 0, 0, 13180, 13181, 7, 12, 0, 0, 13181, 1834, 1, 0, 0, 0, 13182, + 13183, 7, 11, 0, 0, 13183, 13184, 7, 6, 0, 0, 13184, 13185, 7, 19, 0, 0, + 13185, 13186, 7, 9, 0, 0, 13186, 13187, 7, 24, 0, 0, 13187, 13188, 7, 4, + 0, 0, 13188, 13189, 7, 8, 0, 0, 13189, 13190, 7, 9, 0, 0, 13190, 1836, + 1, 0, 0, 0, 13191, 13192, 7, 11, 0, 0, 13192, 13193, 7, 6, 0, 0, 13193, + 13194, 7, 19, 0, 0, 13194, 13195, 7, 9, 0, 0, 13195, 13196, 5, 95, 0, 0, + 13196, 13197, 7, 12, 0, 0, 13197, 13198, 7, 4, 0, 0, 13198, 13199, 7, 3, + 0, 0, 13199, 13200, 7, 19, 0, 0, 13200, 13201, 7, 0, 0, 0, 13201, 13202, + 7, 11, 0, 0, 13202, 1838, 1, 0, 0, 0, 13203, 13204, 7, 11, 0, 0, 13204, + 13205, 7, 6, 0, 0, 13205, 13206, 7, 19, 0, 0, 13206, 13207, 7, 9, 0, 0, + 13207, 13208, 5, 95, 0, 0, 13208, 13209, 7, 6, 0, 0, 13209, 13210, 7, 8, + 0, 0, 13210, 13211, 7, 2, 0, 0, 13211, 13212, 7, 17, 0, 0, 13212, 13213, + 7, 11, 0, 0, 13213, 13214, 5, 95, 0, 0, 13214, 13215, 7, 12, 0, 0, 13215, + 13216, 7, 4, 0, 0, 13216, 13217, 7, 3, 0, 0, 13217, 13218, 7, 19, 0, 0, + 13218, 13219, 7, 0, 0, 0, 13219, 13220, 7, 11, 0, 0, 13220, 1840, 1, 0, + 0, 0, 13221, 13222, 7, 11, 0, 0, 13222, 13223, 7, 6, 0, 0, 13223, 13224, + 7, 19, 0, 0, 13224, 13225, 7, 9, 0, 0, 13225, 13226, 5, 95, 0, 0, 13226, + 13227, 7, 4, 0, 0, 13227, 13228, 7, 17, 0, 0, 13228, 13229, 7, 11, 0, 0, + 13229, 13230, 7, 2, 0, 0, 13230, 13231, 7, 17, 0, 0, 13231, 13232, 7, 11, + 0, 0, 13232, 13233, 5, 95, 0, 0, 13233, 13234, 7, 12, 0, 0, 13234, 13235, + 7, 4, 0, 0, 13235, 13236, 7, 3, 0, 0, 13236, 13237, 7, 19, 0, 0, 13237, + 13238, 7, 0, 0, 0, 13238, 13239, 7, 11, 0, 0, 13239, 1842, 1, 0, 0, 0, + 13240, 13241, 7, 11, 0, 0, 13241, 13242, 7, 4, 0, 0, 13242, 1844, 1, 0, + 0, 0, 13243, 13244, 7, 11, 0, 0, 13244, 13245, 7, 4, 0, 0, 13245, 13246, + 5, 95, 0, 0, 13246, 13247, 7, 10, 0, 0, 13247, 13248, 7, 4, 0, 0, 13248, + 13249, 7, 4, 0, 0, 13249, 13250, 7, 20, 0, 0, 13250, 13251, 7, 9, 0, 0, + 13251, 13252, 7, 0, 0, 0, 13252, 13253, 7, 8, 0, 0, 13253, 1846, 1, 0, + 0, 0, 13254, 13255, 7, 11, 0, 0, 13255, 13256, 7, 4, 0, 0, 13256, 13257, + 5, 95, 0, 0, 13257, 13258, 7, 1, 0, 0, 13258, 13259, 7, 0, 0, 0, 13259, + 13260, 7, 11, 0, 0, 13260, 13261, 7, 9, 0, 0, 13261, 1848, 1, 0, 0, 0, + 13262, 13263, 7, 11, 0, 0, 13263, 13264, 7, 4, 0, 0, 13264, 13265, 7, 2, + 0, 0, 13265, 1850, 1, 0, 0, 0, 13266, 13267, 7, 11, 0, 0, 13267, 13268, + 7, 4, 0, 0, 13268, 13269, 7, 3, 0, 0, 13269, 13270, 7, 8, 0, 0, 13270, + 13271, 5, 95, 0, 0, 13271, 13272, 7, 2, 0, 0, 13272, 13273, 7, 0, 0, 0, + 13273, 13274, 7, 21, 0, 0, 13274, 13275, 7, 9, 0, 0, 13275, 13276, 5, 95, + 0, 0, 13276, 13277, 7, 1, 0, 0, 13277, 13278, 7, 9, 0, 0, 13278, 13279, + 7, 11, 0, 0, 13279, 13280, 7, 9, 0, 0, 13280, 13281, 7, 14, 0, 0, 13281, + 13282, 7, 11, 0, 0, 13282, 13283, 7, 6, 0, 0, 13283, 13284, 7, 4, 0, 0, + 13284, 13285, 7, 8, 0, 0, 13285, 1852, 1, 0, 0, 0, 13286, 13287, 7, 11, + 0, 0, 13287, 13288, 7, 3, 0, 0, 13288, 13289, 7, 0, 0, 0, 13289, 13290, + 7, 14, 0, 0, 13290, 13291, 7, 22, 0, 0, 13291, 13292, 7, 6, 0, 0, 13292, + 13293, 7, 8, 0, 0, 13293, 13294, 7, 21, 0, 0, 13294, 1854, 1, 0, 0, 0, + 13295, 13296, 7, 11, 0, 0, 13296, 13297, 7, 3, 0, 0, 13297, 13298, 7, 0, + 0, 0, 13298, 13299, 7, 14, 0, 0, 13299, 13300, 7, 22, 0, 0, 13300, 13301, + 5, 95, 0, 0, 13301, 13302, 7, 14, 0, 0, 13302, 13303, 7, 0, 0, 0, 13303, + 13304, 7, 17, 0, 0, 13304, 13305, 7, 7, 0, 0, 13305, 13306, 7, 0, 0, 0, + 13306, 13307, 7, 20, 0, 0, 13307, 13308, 7, 6, 0, 0, 13308, 13309, 7, 11, + 0, 0, 13309, 13310, 7, 18, 0, 0, 13310, 1856, 1, 0, 0, 0, 13311, 13312, + 7, 11, 0, 0, 13312, 13313, 7, 3, 0, 0, 13313, 13314, 7, 0, 0, 0, 13314, + 13315, 7, 8, 0, 0, 13315, 1858, 1, 0, 0, 0, 13316, 13317, 7, 11, 0, 0, + 13317, 13318, 7, 3, 0, 0, 13318, 13319, 7, 0, 0, 0, 13319, 13320, 7, 8, + 0, 0, 13320, 13321, 7, 7, 0, 0, 13321, 13322, 7, 0, 0, 0, 13322, 13323, + 7, 14, 0, 0, 13323, 13324, 7, 11, 0, 0, 13324, 13325, 7, 6, 0, 0, 13325, + 13326, 7, 4, 0, 0, 13326, 13327, 7, 8, 0, 0, 13327, 1860, 1, 0, 0, 0, 13328, + 13329, 7, 11, 0, 0, 13329, 13330, 7, 3, 0, 0, 13330, 13331, 7, 0, 0, 0, + 13331, 13332, 7, 8, 0, 0, 13332, 13333, 7, 7, 0, 0, 13333, 13334, 7, 0, + 0, 0, 13334, 13335, 7, 14, 0, 0, 13335, 13336, 7, 11, 0, 0, 13336, 13337, + 7, 6, 0, 0, 13337, 13338, 7, 4, 0, 0, 13338, 13339, 7, 8, 0, 0, 13339, + 13340, 7, 7, 0, 0, 13340, 1862, 1, 0, 0, 0, 13341, 13342, 7, 11, 0, 0, + 13342, 13343, 7, 3, 0, 0, 13343, 13344, 7, 0, 0, 0, 13344, 13345, 7, 8, + 0, 0, 13345, 13346, 7, 7, 0, 0, 13346, 13347, 7, 0, 0, 0, 13347, 13348, + 7, 14, 0, 0, 13348, 13349, 7, 11, 0, 0, 13349, 13350, 7, 6, 0, 0, 13350, + 13351, 7, 4, 0, 0, 13351, 13352, 7, 8, 0, 0, 13352, 13353, 5, 95, 0, 0, + 13353, 13354, 7, 0, 0, 0, 13354, 13355, 7, 10, 0, 0, 13355, 13356, 7, 4, + 0, 0, 13356, 13357, 7, 3, 0, 0, 13357, 13358, 7, 11, 0, 0, 13358, 13359, + 5, 95, 0, 0, 13359, 13360, 7, 4, 0, 0, 13360, 13361, 7, 8, 0, 0, 13361, + 13362, 5, 95, 0, 0, 13362, 13363, 7, 9, 0, 0, 13363, 13364, 7, 3, 0, 0, + 13364, 13365, 7, 3, 0, 0, 13365, 13366, 7, 4, 0, 0, 13366, 13367, 7, 3, + 0, 0, 13367, 1864, 1, 0, 0, 0, 13368, 13369, 7, 11, 0, 0, 13369, 13370, + 7, 3, 0, 0, 13370, 13371, 7, 0, 0, 0, 13371, 13372, 7, 8, 0, 0, 13372, + 13373, 7, 7, 0, 0, 13373, 13374, 7, 0, 0, 0, 13374, 13375, 7, 14, 0, 0, + 13375, 13376, 7, 11, 0, 0, 13376, 13377, 7, 6, 0, 0, 13377, 13378, 7, 4, + 0, 0, 13378, 13379, 7, 8, 0, 0, 13379, 13380, 5, 95, 0, 0, 13380, 13381, + 7, 1, 0, 0, 13381, 13382, 7, 9, 0, 0, 13382, 13383, 7, 12, 0, 0, 13383, + 13384, 7, 0, 0, 0, 13384, 13385, 7, 17, 0, 0, 13385, 13386, 7, 20, 0, 0, + 13386, 13387, 7, 11, 0, 0, 13387, 13388, 5, 95, 0, 0, 13388, 13389, 7, + 6, 0, 0, 13389, 13390, 7, 7, 0, 0, 13390, 13391, 7, 4, 0, 0, 13391, 13392, + 7, 20, 0, 0, 13392, 13393, 7, 0, 0, 0, 13393, 13394, 7, 11, 0, 0, 13394, + 13395, 7, 6, 0, 0, 13395, 13396, 7, 4, 0, 0, 13396, 13397, 7, 8, 0, 0, + 13397, 13398, 5, 95, 0, 0, 13398, 13399, 7, 20, 0, 0, 13399, 13400, 7, + 9, 0, 0, 13400, 13401, 7, 5, 0, 0, 13401, 13402, 7, 9, 0, 0, 13402, 13403, + 7, 20, 0, 0, 13403, 1866, 1, 0, 0, 0, 13404, 13405, 7, 11, 0, 0, 13405, + 13406, 7, 3, 0, 0, 13406, 13407, 7, 0, 0, 0, 13407, 13408, 7, 8, 0, 0, + 13408, 13409, 7, 7, 0, 0, 13409, 13410, 7, 0, 0, 0, 13410, 13411, 7, 14, + 0, 0, 13411, 13412, 7, 11, 0, 0, 13412, 13413, 7, 6, 0, 0, 13413, 13414, + 7, 4, 0, 0, 13414, 13415, 7, 8, 0, 0, 13415, 13416, 5, 95, 0, 0, 13416, + 13417, 7, 6, 0, 0, 13417, 13418, 7, 1, 0, 0, 13418, 1868, 1, 0, 0, 0, 13419, + 13420, 7, 11, 0, 0, 13420, 13421, 7, 3, 0, 0, 13421, 13422, 7, 0, 0, 0, + 13422, 13423, 7, 8, 0, 0, 13423, 13424, 7, 7, 0, 0, 13424, 13425, 7, 12, + 0, 0, 13425, 13426, 7, 4, 0, 0, 13426, 13427, 7, 3, 0, 0, 13427, 13428, + 7, 19, 0, 0, 13428, 13429, 5, 95, 0, 0, 13429, 13430, 7, 8, 0, 0, 13430, + 13431, 7, 4, 0, 0, 13431, 13432, 7, 6, 0, 0, 13432, 13433, 7, 7, 0, 0, + 13433, 13434, 7, 9, 0, 0, 13434, 13435, 5, 95, 0, 0, 13435, 13436, 7, 13, + 0, 0, 13436, 13437, 7, 4, 0, 0, 13437, 13438, 7, 3, 0, 0, 13438, 13439, + 7, 1, 0, 0, 13439, 13440, 7, 7, 0, 0, 13440, 1870, 1, 0, 0, 0, 13441, 13442, + 7, 11, 0, 0, 13442, 13443, 7, 3, 0, 0, 13443, 13444, 7, 0, 0, 0, 13444, + 13445, 7, 8, 0, 0, 13445, 13446, 7, 7, 0, 0, 13446, 13447, 7, 6, 0, 0, + 13447, 13448, 7, 9, 0, 0, 13448, 13449, 7, 8, 0, 0, 13449, 13450, 7, 11, + 0, 0, 13450, 1872, 1, 0, 0, 0, 13451, 13452, 7, 11, 0, 0, 13452, 13453, + 7, 3, 0, 0, 13453, 13454, 7, 0, 0, 0, 13454, 13455, 7, 8, 0, 0, 13455, + 13456, 7, 7, 0, 0, 13456, 13457, 7, 20, 0, 0, 13457, 13458, 7, 0, 0, 0, + 13458, 13459, 7, 11, 0, 0, 13459, 13460, 7, 9, 0, 0, 13460, 1874, 1, 0, + 0, 0, 13461, 13462, 7, 11, 0, 0, 13462, 13463, 7, 3, 0, 0, 13463, 13464, + 7, 6, 0, 0, 13464, 13465, 7, 21, 0, 0, 13465, 13466, 7, 21, 0, 0, 13466, + 13467, 7, 9, 0, 0, 13467, 13468, 7, 3, 0, 0, 13468, 1876, 1, 0, 0, 0, 13469, + 13470, 7, 11, 0, 0, 13470, 13471, 7, 3, 0, 0, 13471, 13472, 7, 6, 0, 0, + 13472, 13473, 7, 21, 0, 0, 13473, 13474, 7, 21, 0, 0, 13474, 13475, 7, + 9, 0, 0, 13475, 13476, 7, 3, 0, 0, 13476, 13477, 7, 7, 0, 0, 13477, 1878, + 1, 0, 0, 0, 13478, 13479, 7, 11, 0, 0, 13479, 13480, 7, 3, 0, 0, 13480, + 13481, 7, 6, 0, 0, 13481, 13482, 7, 19, 0, 0, 13482, 1880, 1, 0, 0, 0, + 13483, 13484, 7, 11, 0, 0, 13484, 13485, 7, 3, 0, 0, 13485, 13486, 7, 6, + 0, 0, 13486, 13487, 7, 19, 0, 0, 13487, 13488, 5, 95, 0, 0, 13488, 13489, + 7, 7, 0, 0, 13489, 13490, 7, 2, 0, 0, 13490, 13491, 7, 0, 0, 0, 13491, + 13492, 7, 14, 0, 0, 13492, 13493, 7, 9, 0, 0, 13493, 1882, 1, 0, 0, 0, + 13494, 13495, 7, 11, 0, 0, 13495, 13496, 7, 3, 0, 0, 13496, 13497, 7, 6, + 0, 0, 13497, 13498, 7, 2, 0, 0, 13498, 13499, 7, 20, 0, 0, 13499, 13500, + 7, 9, 0, 0, 13500, 13501, 5, 95, 0, 0, 13501, 13502, 7, 1, 0, 0, 13502, + 13503, 7, 9, 0, 0, 13503, 13504, 7, 7, 0, 0, 13504, 1884, 1, 0, 0, 0, 13505, + 13506, 7, 11, 0, 0, 13506, 13507, 7, 3, 0, 0, 13507, 13508, 7, 6, 0, 0, + 13508, 13509, 7, 2, 0, 0, 13509, 13510, 7, 20, 0, 0, 13510, 13511, 7, 9, + 0, 0, 13511, 13512, 5, 95, 0, 0, 13512, 13513, 7, 1, 0, 0, 13513, 13514, + 7, 9, 0, 0, 13514, 13515, 7, 7, 0, 0, 13515, 13516, 5, 95, 0, 0, 13516, + 13517, 5, 51, 0, 0, 13517, 13518, 7, 22, 0, 0, 13518, 13519, 7, 9, 0, 0, + 13519, 13520, 7, 18, 0, 0, 13520, 1886, 1, 0, 0, 0, 13521, 13522, 7, 11, + 0, 0, 13522, 13523, 7, 3, 0, 0, 13523, 13524, 7, 17, 0, 0, 13524, 13525, + 7, 9, 0, 0, 13525, 1888, 1, 0, 0, 0, 13526, 13527, 7, 11, 0, 0, 13527, + 13528, 7, 3, 0, 0, 13528, 13529, 7, 17, 0, 0, 13529, 13530, 7, 8, 0, 0, + 13530, 13531, 7, 14, 0, 0, 13531, 13532, 7, 0, 0, 0, 13532, 13533, 7, 11, + 0, 0, 13533, 13534, 7, 9, 0, 0, 13534, 1890, 1, 0, 0, 0, 13535, 13536, + 7, 11, 0, 0, 13536, 13537, 7, 3, 0, 0, 13537, 13538, 7, 17, 0, 0, 13538, + 13539, 7, 8, 0, 0, 13539, 13540, 7, 14, 0, 0, 13540, 13541, 7, 0, 0, 0, + 13541, 13542, 7, 11, 0, 0, 13542, 13543, 7, 9, 0, 0, 13543, 13544, 7, 14, + 0, 0, 13544, 13545, 7, 4, 0, 0, 13545, 13546, 7, 20, 0, 0, 13546, 13547, + 7, 17, 0, 0, 13547, 13548, 7, 19, 0, 0, 13548, 13549, 7, 8, 0, 0, 13549, + 13550, 7, 7, 0, 0, 13550, 1892, 1, 0, 0, 0, 13551, 13552, 7, 11, 0, 0, + 13552, 13553, 7, 3, 0, 0, 13553, 13554, 7, 17, 0, 0, 13554, 13555, 7, 7, + 0, 0, 13555, 13556, 7, 11, 0, 0, 13556, 13557, 7, 13, 0, 0, 13557, 13558, + 7, 4, 0, 0, 13558, 13559, 7, 3, 0, 0, 13559, 13560, 7, 11, 0, 0, 13560, + 13561, 7, 15, 0, 0, 13561, 13562, 7, 18, 0, 0, 13562, 1894, 1, 0, 0, 0, + 13563, 13564, 7, 11, 0, 0, 13564, 13565, 7, 3, 0, 0, 13565, 13566, 7, 18, + 0, 0, 13566, 1896, 1, 0, 0, 0, 13567, 13568, 7, 11, 0, 0, 13568, 13569, + 7, 3, 0, 0, 13569, 13570, 7, 18, 0, 0, 13570, 13571, 5, 95, 0, 0, 13571, + 13572, 7, 14, 0, 0, 13572, 13573, 7, 0, 0, 0, 13573, 13574, 7, 7, 0, 0, + 13574, 13575, 7, 11, 0, 0, 13575, 1898, 1, 0, 0, 0, 13576, 13577, 7, 11, + 0, 0, 13577, 13578, 7, 7, 0, 0, 13578, 13579, 7, 9, 0, 0, 13579, 13580, + 7, 16, 0, 0, 13580, 13581, 7, 17, 0, 0, 13581, 13582, 7, 0, 0, 0, 13582, + 13583, 7, 20, 0, 0, 13583, 1900, 1, 0, 0, 0, 13584, 13585, 7, 11, 0, 0, + 13585, 13586, 7, 7, 0, 0, 13586, 13587, 7, 16, 0, 0, 13587, 13588, 7, 20, + 0, 0, 13588, 1902, 1, 0, 0, 0, 13589, 13590, 7, 11, 0, 0, 13590, 13591, + 7, 13, 0, 0, 13591, 13592, 7, 4, 0, 0, 13592, 13593, 5, 95, 0, 0, 13593, + 13594, 7, 1, 0, 0, 13594, 13595, 7, 6, 0, 0, 13595, 13596, 7, 21, 0, 0, + 13596, 13597, 7, 6, 0, 0, 13597, 13598, 7, 11, 0, 0, 13598, 13599, 5, 95, + 0, 0, 13599, 13600, 7, 14, 0, 0, 13600, 13601, 7, 9, 0, 0, 13601, 13602, + 7, 8, 0, 0, 13602, 13603, 7, 11, 0, 0, 13603, 13604, 7, 17, 0, 0, 13604, + 13605, 7, 3, 0, 0, 13605, 13606, 7, 18, 0, 0, 13606, 13607, 5, 95, 0, 0, + 13607, 13608, 7, 7, 0, 0, 13608, 13609, 7, 11, 0, 0, 13609, 13610, 7, 0, + 0, 0, 13610, 13611, 7, 3, 0, 0, 13611, 13612, 7, 11, 0, 0, 13612, 1904, + 1, 0, 0, 0, 13613, 13614, 7, 11, 0, 0, 13614, 13615, 7, 13, 0, 0, 13615, + 13616, 7, 4, 0, 0, 13616, 13617, 5, 95, 0, 0, 13617, 13618, 7, 1, 0, 0, + 13618, 13619, 7, 6, 0, 0, 13619, 13620, 7, 21, 0, 0, 13620, 13621, 7, 6, + 0, 0, 13621, 13622, 7, 11, 0, 0, 13622, 13623, 5, 95, 0, 0, 13623, 13624, + 7, 18, 0, 0, 13624, 13625, 7, 9, 0, 0, 13625, 13626, 7, 0, 0, 0, 13626, + 13627, 7, 3, 0, 0, 13627, 13628, 5, 95, 0, 0, 13628, 13629, 7, 14, 0, 0, + 13629, 13630, 7, 17, 0, 0, 13630, 13631, 7, 11, 0, 0, 13631, 13632, 7, + 4, 0, 0, 13632, 13633, 7, 12, 0, 0, 13633, 13634, 7, 12, 0, 0, 13634, 1906, + 1, 0, 0, 0, 13635, 13636, 7, 11, 0, 0, 13636, 13637, 7, 18, 0, 0, 13637, + 13638, 7, 2, 0, 0, 13638, 13639, 7, 9, 0, 0, 13639, 1908, 1, 0, 0, 0, 13640, + 13641, 7, 11, 0, 0, 13641, 13642, 7, 18, 0, 0, 13642, 13643, 7, 2, 0, 0, + 13643, 13644, 7, 9, 0, 0, 13644, 13645, 7, 2, 0, 0, 13645, 13646, 7, 3, + 0, 0, 13646, 13647, 7, 4, 0, 0, 13647, 13648, 7, 2, 0, 0, 13648, 13649, + 7, 9, 0, 0, 13649, 13650, 7, 3, 0, 0, 13650, 13651, 7, 11, 0, 0, 13651, + 13652, 7, 18, 0, 0, 13652, 1910, 1, 0, 0, 0, 13653, 13654, 7, 11, 0, 0, + 13654, 13655, 7, 18, 0, 0, 13655, 13656, 7, 2, 0, 0, 13656, 13657, 7, 9, + 0, 0, 13657, 13658, 5, 95, 0, 0, 13658, 13659, 7, 6, 0, 0, 13659, 13660, + 7, 1, 0, 0, 13660, 1912, 1, 0, 0, 0, 13661, 13662, 7, 11, 0, 0, 13662, + 13663, 7, 18, 0, 0, 13663, 13664, 7, 2, 0, 0, 13664, 13665, 7, 9, 0, 0, + 13665, 13666, 5, 95, 0, 0, 13666, 13667, 7, 8, 0, 0, 13667, 13668, 7, 0, + 0, 0, 13668, 13669, 7, 19, 0, 0, 13669, 13670, 7, 9, 0, 0, 13670, 1914, + 1, 0, 0, 0, 13671, 13672, 7, 11, 0, 0, 13672, 13673, 7, 18, 0, 0, 13673, + 13674, 7, 2, 0, 0, 13674, 13675, 7, 9, 0, 0, 13675, 13676, 5, 95, 0, 0, + 13676, 13677, 7, 13, 0, 0, 13677, 13678, 7, 0, 0, 0, 13678, 13679, 7, 3, + 0, 0, 13679, 13680, 7, 8, 0, 0, 13680, 13681, 7, 6, 0, 0, 13681, 13682, + 7, 8, 0, 0, 13682, 13683, 7, 21, 0, 0, 13683, 1916, 1, 0, 0, 0, 13684, + 13685, 7, 17, 0, 0, 13685, 13686, 7, 8, 0, 0, 13686, 1918, 1, 0, 0, 0, + 13687, 13688, 7, 17, 0, 0, 13688, 13689, 7, 8, 0, 0, 13689, 13690, 7, 10, + 0, 0, 13690, 13691, 7, 4, 0, 0, 13691, 13692, 7, 17, 0, 0, 13692, 13693, + 7, 8, 0, 0, 13693, 13694, 7, 1, 0, 0, 13694, 13695, 7, 9, 0, 0, 13695, + 13696, 7, 1, 0, 0, 13696, 1920, 1, 0, 0, 0, 13697, 13698, 7, 17, 0, 0, + 13698, 13699, 7, 8, 0, 0, 13699, 13700, 7, 14, 0, 0, 13700, 13701, 7, 15, + 0, 0, 13701, 13702, 7, 9, 0, 0, 13702, 13703, 7, 14, 0, 0, 13703, 13704, + 7, 22, 0, 0, 13704, 13705, 7, 9, 0, 0, 13705, 13706, 7, 1, 0, 0, 13706, + 1922, 1, 0, 0, 0, 13707, 13708, 7, 17, 0, 0, 13708, 13709, 7, 8, 0, 0, + 13709, 13710, 7, 14, 0, 0, 13710, 13711, 7, 4, 0, 0, 13711, 13712, 7, 19, + 0, 0, 13712, 13713, 7, 19, 0, 0, 13713, 13714, 7, 6, 0, 0, 13714, 13715, + 7, 11, 0, 0, 13715, 13716, 7, 11, 0, 0, 13716, 13717, 7, 9, 0, 0, 13717, + 13718, 7, 1, 0, 0, 13718, 1924, 1, 0, 0, 0, 13719, 13720, 7, 17, 0, 0, + 13720, 13721, 7, 8, 0, 0, 13721, 13722, 7, 1, 0, 0, 13722, 13723, 7, 3, + 0, 0, 13723, 13724, 7, 4, 0, 0, 13724, 13725, 7, 2, 0, 0, 13725, 1926, + 1, 0, 0, 0, 13726, 13727, 7, 17, 0, 0, 13727, 13728, 7, 8, 0, 0, 13728, + 13729, 7, 6, 0, 0, 13729, 13730, 7, 14, 0, 0, 13730, 13731, 7, 4, 0, 0, + 13731, 13732, 7, 1, 0, 0, 13732, 13733, 7, 9, 0, 0, 13733, 1928, 1, 0, + 0, 0, 13734, 13735, 7, 17, 0, 0, 13735, 13736, 7, 8, 0, 0, 13736, 13737, + 7, 6, 0, 0, 13737, 13738, 7, 4, 0, 0, 13738, 13739, 7, 8, 0, 0, 13739, + 1930, 1, 0, 0, 0, 13740, 13741, 7, 17, 0, 0, 13741, 13742, 7, 8, 0, 0, + 13742, 13743, 7, 6, 0, 0, 13743, 13744, 7, 16, 0, 0, 13744, 13745, 7, 17, + 0, 0, 13745, 13746, 7, 9, 0, 0, 13746, 1932, 1, 0, 0, 0, 13747, 13748, + 7, 17, 0, 0, 13748, 13749, 7, 8, 0, 0, 13749, 13750, 7, 22, 0, 0, 13750, + 13751, 7, 8, 0, 0, 13751, 13752, 7, 4, 0, 0, 13752, 13753, 7, 13, 0, 0, + 13753, 13754, 7, 8, 0, 0, 13754, 1934, 1, 0, 0, 0, 13755, 13756, 7, 17, + 0, 0, 13756, 13757, 7, 8, 0, 0, 13757, 13758, 7, 20, 0, 0, 13758, 13759, + 7, 6, 0, 0, 13759, 13760, 7, 19, 0, 0, 13760, 13761, 7, 6, 0, 0, 13761, + 13762, 7, 11, 0, 0, 13762, 13763, 7, 9, 0, 0, 13763, 13764, 7, 1, 0, 0, + 13764, 1936, 1, 0, 0, 0, 13765, 13766, 7, 17, 0, 0, 13766, 13767, 7, 8, + 0, 0, 13767, 13768, 7, 20, 0, 0, 13768, 13769, 7, 4, 0, 0, 13769, 13770, + 7, 14, 0, 0, 13770, 13771, 7, 22, 0, 0, 13771, 1938, 1, 0, 0, 0, 13772, + 13773, 7, 17, 0, 0, 13773, 13774, 7, 8, 0, 0, 13774, 13775, 7, 19, 0, 0, + 13775, 13776, 7, 0, 0, 0, 13776, 13777, 7, 7, 0, 0, 13777, 13778, 7, 22, + 0, 0, 13778, 1940, 1, 0, 0, 0, 13779, 13780, 7, 17, 0, 0, 13780, 13781, + 7, 8, 0, 0, 13781, 13782, 7, 19, 0, 0, 13782, 13783, 7, 0, 0, 0, 13783, + 13784, 7, 11, 0, 0, 13784, 13785, 7, 14, 0, 0, 13785, 13786, 7, 15, 0, + 0, 13786, 13787, 7, 9, 0, 0, 13787, 13788, 7, 1, 0, 0, 13788, 1942, 1, + 0, 0, 0, 13789, 13790, 7, 17, 0, 0, 13790, 13791, 7, 8, 0, 0, 13791, 13792, + 7, 2, 0, 0, 13792, 13793, 7, 6, 0, 0, 13793, 13794, 7, 5, 0, 0, 13794, + 13795, 7, 4, 0, 0, 13795, 13796, 7, 11, 0, 0, 13796, 1944, 1, 0, 0, 0, + 13797, 13798, 7, 17, 0, 0, 13798, 13799, 7, 8, 0, 0, 13799, 13800, 7, 7, + 0, 0, 13800, 13801, 7, 0, 0, 0, 13801, 13802, 7, 12, 0, 0, 13802, 13803, + 7, 9, 0, 0, 13803, 1946, 1, 0, 0, 0, 13804, 13805, 7, 17, 0, 0, 13805, + 13806, 7, 8, 0, 0, 13806, 13807, 7, 7, 0, 0, 13807, 13808, 7, 9, 0, 0, + 13808, 13809, 7, 11, 0, 0, 13809, 1948, 1, 0, 0, 0, 13810, 13811, 7, 17, + 0, 0, 13811, 13812, 7, 8, 0, 0, 13812, 13813, 7, 7, 0, 0, 13813, 13814, + 7, 17, 0, 0, 13814, 13815, 7, 2, 0, 0, 13815, 13816, 7, 2, 0, 0, 13816, + 13817, 7, 4, 0, 0, 13817, 13818, 7, 3, 0, 0, 13818, 13819, 7, 11, 0, 0, + 13819, 13820, 7, 9, 0, 0, 13820, 13821, 7, 1, 0, 0, 13821, 13822, 5, 95, + 0, 0, 13822, 13823, 7, 1, 0, 0, 13823, 13824, 7, 1, 0, 0, 13824, 13825, + 7, 20, 0, 0, 13825, 13826, 5, 95, 0, 0, 13826, 13827, 7, 0, 0, 0, 13827, + 13828, 7, 14, 0, 0, 13828, 13829, 7, 11, 0, 0, 13829, 13830, 7, 6, 0, 0, + 13830, 13831, 7, 4, 0, 0, 13831, 13832, 7, 8, 0, 0, 13832, 1950, 1, 0, + 0, 0, 13833, 13834, 7, 17, 0, 0, 13834, 13835, 7, 4, 0, 0, 13835, 13836, + 7, 13, 0, 0, 13836, 1952, 1, 0, 0, 0, 13837, 13838, 7, 17, 0, 0, 13838, + 13839, 7, 2, 0, 0, 13839, 13840, 7, 1, 0, 0, 13840, 13841, 7, 0, 0, 0, + 13841, 13842, 7, 11, 0, 0, 13842, 13843, 7, 9, 0, 0, 13843, 1954, 1, 0, + 0, 0, 13844, 13845, 7, 17, 0, 0, 13845, 13846, 7, 2, 0, 0, 13846, 13847, + 7, 1, 0, 0, 13847, 13848, 7, 20, 0, 0, 13848, 13849, 7, 4, 0, 0, 13849, + 13850, 7, 14, 0, 0, 13850, 13851, 7, 22, 0, 0, 13851, 1956, 1, 0, 0, 0, + 13852, 13853, 7, 17, 0, 0, 13853, 13854, 7, 2, 0, 0, 13854, 13855, 7, 2, + 0, 0, 13855, 13856, 7, 9, 0, 0, 13856, 13857, 7, 3, 0, 0, 13857, 1958, + 1, 0, 0, 0, 13858, 13859, 7, 17, 0, 0, 13859, 13860, 7, 3, 0, 0, 13860, + 13861, 7, 20, 0, 0, 13861, 1960, 1, 0, 0, 0, 13862, 13863, 7, 17, 0, 0, + 13863, 13864, 7, 7, 0, 0, 13864, 13865, 7, 0, 0, 0, 13865, 13866, 7, 21, + 0, 0, 13866, 13867, 7, 9, 0, 0, 13867, 1962, 1, 0, 0, 0, 13868, 13869, + 7, 17, 0, 0, 13869, 13870, 7, 7, 0, 0, 13870, 13871, 7, 9, 0, 0, 13871, + 1964, 1, 0, 0, 0, 13872, 13873, 7, 17, 0, 0, 13873, 13874, 7, 7, 0, 0, + 13874, 13875, 7, 9, 0, 0, 13875, 13876, 7, 1, 0, 0, 13876, 1966, 1, 0, + 0, 0, 13877, 13878, 7, 17, 0, 0, 13878, 13879, 7, 7, 0, 0, 13879, 13880, + 7, 9, 0, 0, 13880, 13881, 7, 3, 0, 0, 13881, 1968, 1, 0, 0, 0, 13882, 13883, + 7, 17, 0, 0, 13883, 13884, 7, 7, 0, 0, 13884, 13885, 7, 9, 0, 0, 13885, + 13886, 7, 3, 0, 0, 13886, 13887, 7, 0, 0, 0, 13887, 13888, 7, 1, 0, 0, + 13888, 13889, 7, 19, 0, 0, 13889, 13890, 7, 6, 0, 0, 13890, 13891, 7, 8, + 0, 0, 13891, 1970, 1, 0, 0, 0, 13892, 13893, 7, 17, 0, 0, 13893, 13894, + 7, 7, 0, 0, 13894, 13895, 7, 9, 0, 0, 13895, 13896, 7, 3, 0, 0, 13896, + 13897, 7, 7, 0, 0, 13897, 1972, 1, 0, 0, 0, 13898, 13899, 7, 17, 0, 0, + 13899, 13900, 7, 7, 0, 0, 13900, 13901, 7, 9, 0, 0, 13901, 13902, 7, 3, + 0, 0, 13902, 13903, 5, 95, 0, 0, 13903, 13904, 7, 7, 0, 0, 13904, 13905, + 7, 2, 0, 0, 13905, 13906, 7, 9, 0, 0, 13906, 13907, 7, 14, 0, 0, 13907, + 13908, 7, 6, 0, 0, 13908, 13909, 7, 12, 0, 0, 13909, 13910, 7, 6, 0, 0, + 13910, 13911, 7, 9, 0, 0, 13911, 13912, 7, 1, 0, 0, 13912, 1974, 1, 0, + 0, 0, 13913, 13914, 7, 17, 0, 0, 13914, 13915, 7, 7, 0, 0, 13915, 13916, + 7, 9, 0, 0, 13916, 13917, 7, 3, 0, 0, 13917, 13918, 5, 95, 0, 0, 13918, + 13919, 7, 11, 0, 0, 13919, 13920, 7, 0, 0, 0, 13920, 13921, 7, 7, 0, 0, + 13921, 13922, 7, 22, 0, 0, 13922, 13923, 5, 95, 0, 0, 13923, 13924, 7, + 19, 0, 0, 13924, 13925, 7, 0, 0, 0, 13925, 13926, 7, 8, 0, 0, 13926, 13927, + 7, 0, 0, 0, 13927, 13928, 7, 21, 0, 0, 13928, 13929, 7, 9, 0, 0, 13929, + 13930, 7, 1, 0, 0, 13930, 13931, 5, 95, 0, 0, 13931, 13932, 7, 6, 0, 0, + 13932, 13933, 7, 8, 0, 0, 13933, 13934, 7, 6, 0, 0, 13934, 13935, 7, 11, + 0, 0, 13935, 13936, 7, 6, 0, 0, 13936, 13937, 7, 0, 0, 0, 13937, 13938, + 7, 20, 0, 0, 13938, 13939, 5, 95, 0, 0, 13939, 13940, 7, 13, 0, 0, 13940, + 13941, 7, 0, 0, 0, 13941, 13942, 7, 3, 0, 0, 13942, 13943, 7, 9, 0, 0, + 13943, 13944, 7, 15, 0, 0, 13944, 13945, 7, 4, 0, 0, 13945, 13946, 7, 17, + 0, 0, 13946, 13947, 7, 7, 0, 0, 13947, 13948, 7, 9, 0, 0, 13948, 13949, + 5, 95, 0, 0, 13949, 13950, 7, 7, 0, 0, 13950, 13951, 7, 6, 0, 0, 13951, + 13952, 7, 24, 0, 0, 13952, 13953, 7, 9, 0, 0, 13953, 1976, 1, 0, 0, 0, + 13954, 13955, 7, 17, 0, 0, 13955, 13956, 7, 7, 0, 0, 13956, 13957, 7, 9, + 0, 0, 13957, 13958, 7, 3, 0, 0, 13958, 13959, 5, 95, 0, 0, 13959, 13960, + 7, 11, 0, 0, 13960, 13961, 7, 0, 0, 0, 13961, 13962, 7, 7, 0, 0, 13962, + 13963, 7, 22, 0, 0, 13963, 13964, 5, 95, 0, 0, 13964, 13965, 7, 11, 0, + 0, 13965, 13966, 7, 6, 0, 0, 13966, 13967, 7, 19, 0, 0, 13967, 13968, 7, + 9, 0, 0, 13968, 13969, 7, 4, 0, 0, 13969, 13970, 7, 17, 0, 0, 13970, 13971, + 7, 11, 0, 0, 13971, 13972, 5, 95, 0, 0, 13972, 13973, 7, 19, 0, 0, 13973, + 13974, 7, 7, 0, 0, 13974, 1978, 1, 0, 0, 0, 13975, 13976, 7, 17, 0, 0, + 13976, 13977, 7, 7, 0, 0, 13977, 13978, 7, 9, 0, 0, 13978, 13979, 5, 95, + 0, 0, 13979, 13980, 7, 0, 0, 0, 13980, 13981, 7, 8, 0, 0, 13981, 13982, + 7, 18, 0, 0, 13982, 13983, 5, 95, 0, 0, 13983, 13984, 7, 3, 0, 0, 13984, + 13985, 7, 4, 0, 0, 13985, 13986, 7, 20, 0, 0, 13986, 13987, 7, 9, 0, 0, + 13987, 1980, 1, 0, 0, 0, 13988, 13989, 7, 17, 0, 0, 13989, 13990, 7, 7, + 0, 0, 13990, 13991, 7, 9, 0, 0, 13991, 13992, 5, 95, 0, 0, 13992, 13993, + 7, 14, 0, 0, 13993, 13994, 7, 0, 0, 0, 13994, 13995, 7, 14, 0, 0, 13995, + 13996, 7, 15, 0, 0, 13996, 13997, 7, 9, 0, 0, 13997, 13998, 7, 1, 0, 0, + 13998, 13999, 5, 95, 0, 0, 13999, 14000, 7, 3, 0, 0, 14000, 14001, 7, 9, + 0, 0, 14001, 14002, 7, 7, 0, 0, 14002, 14003, 7, 17, 0, 0, 14003, 14004, + 7, 20, 0, 0, 14004, 14005, 7, 11, 0, 0, 14005, 1982, 1, 0, 0, 0, 14006, + 14007, 7, 17, 0, 0, 14007, 14008, 7, 7, 0, 0, 14008, 14009, 7, 6, 0, 0, + 14009, 14010, 7, 8, 0, 0, 14010, 14011, 7, 21, 0, 0, 14011, 1984, 1, 0, + 0, 0, 14012, 14013, 7, 17, 0, 0, 14013, 14014, 7, 11, 0, 0, 14014, 14015, + 7, 12, 0, 0, 14015, 14016, 5, 56, 0, 0, 14016, 1986, 1, 0, 0, 0, 14017, + 14018, 7, 5, 0, 0, 14018, 14019, 7, 0, 0, 0, 14019, 14020, 7, 20, 0, 0, + 14020, 14021, 7, 6, 0, 0, 14021, 14022, 7, 1, 0, 0, 14022, 14023, 7, 0, + 0, 0, 14023, 14024, 7, 11, 0, 0, 14024, 14025, 7, 9, 0, 0, 14025, 1988, + 1, 0, 0, 0, 14026, 14027, 7, 5, 0, 0, 14027, 14028, 7, 0, 0, 0, 14028, + 14029, 7, 20, 0, 0, 14029, 14030, 7, 6, 0, 0, 14030, 14031, 7, 1, 0, 0, + 14031, 14032, 7, 0, 0, 0, 14032, 14033, 7, 11, 0, 0, 14033, 14034, 7, 6, + 0, 0, 14034, 14035, 7, 4, 0, 0, 14035, 14036, 7, 8, 0, 0, 14036, 1990, + 1, 0, 0, 0, 14037, 14038, 7, 5, 0, 0, 14038, 14039, 7, 0, 0, 0, 14039, + 14040, 7, 20, 0, 0, 14040, 14041, 7, 6, 0, 0, 14041, 14042, 7, 1, 0, 0, + 14042, 14043, 7, 0, 0, 0, 14043, 14044, 7, 11, 0, 0, 14044, 14045, 7, 6, + 0, 0, 14045, 14046, 7, 4, 0, 0, 14046, 14047, 7, 8, 0, 0, 14047, 14048, + 5, 95, 0, 0, 14048, 14049, 7, 19, 0, 0, 14049, 14050, 7, 4, 0, 0, 14050, + 14051, 7, 1, 0, 0, 14051, 14052, 7, 9, 0, 0, 14052, 1992, 1, 0, 0, 0, 14053, + 14054, 7, 5, 0, 0, 14054, 14055, 7, 0, 0, 0, 14055, 14056, 7, 20, 0, 0, + 14056, 14057, 7, 6, 0, 0, 14057, 14058, 7, 1, 0, 0, 14058, 14059, 5, 95, + 0, 0, 14059, 14060, 7, 23, 0, 0, 14060, 14061, 7, 19, 0, 0, 14061, 14062, + 7, 20, 0, 0, 14062, 1994, 1, 0, 0, 0, 14063, 14064, 7, 5, 0, 0, 14064, + 14065, 7, 0, 0, 0, 14065, 14066, 7, 20, 0, 0, 14066, 14067, 7, 17, 0, 0, + 14067, 14068, 7, 9, 0, 0, 14068, 1996, 1, 0, 0, 0, 14069, 14070, 7, 5, + 0, 0, 14070, 14071, 7, 0, 0, 0, 14071, 14072, 7, 20, 0, 0, 14072, 14073, + 7, 17, 0, 0, 14073, 14074, 7, 9, 0, 0, 14074, 14075, 7, 7, 0, 0, 14075, + 1998, 1, 0, 0, 0, 14076, 14077, 7, 5, 0, 0, 14077, 14078, 7, 0, 0, 0, 14078, + 14079, 7, 3, 0, 0, 14079, 2000, 1, 0, 0, 0, 14080, 14081, 7, 5, 0, 0, 14081, + 14082, 7, 0, 0, 0, 14082, 14083, 7, 3, 0, 0, 14083, 14084, 7, 6, 0, 0, + 14084, 14085, 7, 0, 0, 0, 14085, 14086, 7, 10, 0, 0, 14086, 14087, 7, 20, + 0, 0, 14087, 14088, 7, 9, 0, 0, 14088, 14089, 7, 7, 0, 0, 14089, 2002, + 1, 0, 0, 0, 14090, 14091, 7, 5, 0, 0, 14091, 14092, 7, 0, 0, 0, 14092, + 14093, 7, 3, 0, 0, 14093, 14094, 7, 2, 0, 0, 14094, 2004, 1, 0, 0, 0, 14095, + 14096, 7, 5, 0, 0, 14096, 14097, 7, 0, 0, 0, 14097, 14098, 7, 3, 0, 0, + 14098, 14099, 7, 18, 0, 0, 14099, 14100, 7, 6, 0, 0, 14100, 14101, 7, 8, + 0, 0, 14101, 14102, 7, 21, 0, 0, 14102, 2006, 1, 0, 0, 0, 14103, 14104, + 7, 5, 0, 0, 14104, 14105, 7, 9, 0, 0, 14105, 14106, 7, 3, 0, 0, 14106, + 14107, 7, 7, 0, 0, 14107, 14108, 7, 6, 0, 0, 14108, 14109, 7, 4, 0, 0, + 14109, 14110, 7, 8, 0, 0, 14110, 2008, 1, 0, 0, 0, 14111, 14112, 7, 5, + 0, 0, 14112, 14113, 7, 6, 0, 0, 14113, 14114, 7, 9, 0, 0, 14114, 14115, + 7, 13, 0, 0, 14115, 2010, 1, 0, 0, 0, 14116, 14117, 7, 5, 0, 0, 14117, + 14118, 7, 6, 0, 0, 14118, 14119, 7, 9, 0, 0, 14119, 14120, 7, 13, 0, 0, + 14120, 14121, 7, 7, 0, 0, 14121, 2012, 1, 0, 0, 0, 14122, 14123, 7, 5, + 0, 0, 14123, 14124, 7, 6, 0, 0, 14124, 14125, 7, 9, 0, 0, 14125, 14126, + 7, 13, 0, 0, 14126, 14127, 5, 95, 0, 0, 14127, 14128, 7, 19, 0, 0, 14128, + 14129, 7, 9, 0, 0, 14129, 14130, 7, 11, 0, 0, 14130, 14131, 7, 0, 0, 0, + 14131, 14132, 7, 1, 0, 0, 14132, 14133, 7, 0, 0, 0, 14133, 14134, 7, 11, + 0, 0, 14134, 14135, 7, 0, 0, 0, 14135, 2014, 1, 0, 0, 0, 14136, 14137, + 7, 5, 0, 0, 14137, 14138, 7, 6, 0, 0, 14138, 14139, 7, 7, 0, 0, 14139, + 14140, 7, 6, 0, 0, 14140, 14141, 7, 10, 0, 0, 14141, 14142, 7, 6, 0, 0, + 14142, 14143, 7, 20, 0, 0, 14143, 14144, 7, 6, 0, 0, 14144, 14145, 7, 11, + 0, 0, 14145, 14146, 7, 18, 0, 0, 14146, 2016, 1, 0, 0, 0, 14147, 14148, + 7, 5, 0, 0, 14148, 14149, 7, 4, 0, 0, 14149, 14150, 7, 20, 0, 0, 14150, + 14151, 7, 0, 0, 0, 14151, 14152, 7, 11, 0, 0, 14152, 14153, 7, 6, 0, 0, + 14153, 14154, 7, 20, 0, 0, 14154, 14155, 7, 9, 0, 0, 14155, 2018, 1, 0, + 0, 0, 14156, 14157, 7, 13, 0, 0, 14157, 14158, 7, 0, 0, 0, 14158, 14159, + 7, 6, 0, 0, 14159, 14160, 7, 11, 0, 0, 14160, 2020, 1, 0, 0, 0, 14161, + 14162, 7, 13, 0, 0, 14162, 14163, 7, 0, 0, 0, 14163, 14164, 7, 3, 0, 0, + 14164, 14165, 7, 9, 0, 0, 14165, 14166, 7, 15, 0, 0, 14166, 14167, 7, 4, + 0, 0, 14167, 14168, 7, 17, 0, 0, 14168, 14169, 7, 7, 0, 0, 14169, 14170, + 7, 9, 0, 0, 14170, 2022, 1, 0, 0, 0, 14171, 14172, 7, 13, 0, 0, 14172, + 14173, 7, 0, 0, 0, 14173, 14174, 7, 3, 0, 0, 14174, 14175, 7, 9, 0, 0, + 14175, 14176, 7, 15, 0, 0, 14176, 14177, 7, 4, 0, 0, 14177, 14178, 7, 17, + 0, 0, 14178, 14179, 7, 7, 0, 0, 14179, 14180, 7, 9, 0, 0, 14180, 14181, + 7, 7, 0, 0, 14181, 2024, 1, 0, 0, 0, 14182, 14183, 7, 13, 0, 0, 14183, + 14184, 7, 0, 0, 0, 14184, 14185, 7, 3, 0, 0, 14185, 14186, 7, 9, 0, 0, + 14186, 14187, 7, 15, 0, 0, 14187, 14188, 7, 4, 0, 0, 14188, 14189, 7, 17, + 0, 0, 14189, 14190, 7, 7, 0, 0, 14190, 14191, 7, 9, 0, 0, 14191, 14192, + 5, 95, 0, 0, 14192, 14193, 7, 7, 0, 0, 14193, 14194, 7, 6, 0, 0, 14194, + 14195, 7, 24, 0, 0, 14195, 14196, 7, 9, 0, 0, 14196, 2026, 1, 0, 0, 0, + 14197, 14198, 7, 13, 0, 0, 14198, 14199, 7, 9, 0, 0, 14199, 14200, 7, 9, + 0, 0, 14200, 14201, 7, 22, 0, 0, 14201, 14202, 7, 20, 0, 0, 14202, 14203, + 7, 18, 0, 0, 14203, 2028, 1, 0, 0, 0, 14204, 14205, 7, 13, 0, 0, 14205, + 14206, 7, 9, 0, 0, 14206, 14207, 7, 9, 0, 0, 14207, 14208, 7, 22, 0, 0, + 14208, 14209, 5, 95, 0, 0, 14209, 14210, 7, 4, 0, 0, 14210, 14211, 7, 12, + 0, 0, 14211, 14212, 5, 95, 0, 0, 14212, 14213, 7, 18, 0, 0, 14213, 14214, + 7, 9, 0, 0, 14214, 14215, 7, 0, 0, 0, 14215, 14216, 7, 3, 0, 0, 14216, + 14217, 5, 95, 0, 0, 14217, 14218, 7, 2, 0, 0, 14218, 14219, 7, 4, 0, 0, + 14219, 14220, 7, 20, 0, 0, 14220, 14221, 7, 6, 0, 0, 14221, 14222, 7, 14, + 0, 0, 14222, 14223, 7, 18, 0, 0, 14223, 2030, 1, 0, 0, 0, 14224, 14225, + 7, 13, 0, 0, 14225, 14226, 7, 9, 0, 0, 14226, 14227, 7, 9, 0, 0, 14227, + 14228, 7, 22, 0, 0, 14228, 14229, 5, 95, 0, 0, 14229, 14230, 7, 7, 0, 0, + 14230, 14231, 7, 11, 0, 0, 14231, 14232, 7, 0, 0, 0, 14232, 14233, 7, 3, + 0, 0, 14233, 14234, 7, 11, 0, 0, 14234, 2032, 1, 0, 0, 0, 14235, 14236, + 7, 13, 0, 0, 14236, 14237, 7, 9, 0, 0, 14237, 14238, 7, 20, 0, 0, 14238, + 14239, 7, 20, 0, 0, 14239, 14240, 5, 95, 0, 0, 14240, 14241, 7, 12, 0, + 0, 14241, 14242, 7, 4, 0, 0, 14242, 14243, 7, 3, 0, 0, 14243, 14244, 7, + 19, 0, 0, 14244, 14245, 7, 9, 0, 0, 14245, 14246, 7, 1, 0, 0, 14246, 14247, + 5, 95, 0, 0, 14247, 14248, 7, 23, 0, 0, 14248, 14249, 7, 19, 0, 0, 14249, + 14250, 7, 20, 0, 0, 14250, 2034, 1, 0, 0, 0, 14251, 14252, 7, 13, 0, 0, + 14252, 14253, 7, 15, 0, 0, 14253, 14254, 7, 9, 0, 0, 14254, 14255, 7, 8, + 0, 0, 14255, 2036, 1, 0, 0, 0, 14256, 14257, 7, 13, 0, 0, 14257, 14258, + 7, 15, 0, 0, 14258, 14259, 7, 9, 0, 0, 14259, 14260, 7, 3, 0, 0, 14260, + 14261, 7, 9, 0, 0, 14261, 2038, 1, 0, 0, 0, 14262, 14263, 7, 13, 0, 0, + 14263, 14264, 7, 6, 0, 0, 14264, 14265, 7, 11, 0, 0, 14265, 14266, 7, 15, + 0, 0, 14266, 2040, 1, 0, 0, 0, 14267, 14268, 7, 13, 0, 0, 14268, 14269, + 7, 6, 0, 0, 14269, 14270, 7, 11, 0, 0, 14270, 14271, 7, 15, 0, 0, 14271, + 14272, 7, 6, 0, 0, 14272, 14273, 7, 8, 0, 0, 14273, 2042, 1, 0, 0, 0, 14274, + 14275, 7, 13, 0, 0, 14275, 14276, 7, 6, 0, 0, 14276, 14277, 7, 11, 0, 0, + 14277, 14278, 7, 15, 0, 0, 14278, 14279, 7, 4, 0, 0, 14279, 14280, 7, 17, + 0, 0, 14280, 14281, 7, 11, 0, 0, 14281, 2044, 1, 0, 0, 0, 14282, 14283, + 7, 13, 0, 0, 14283, 14284, 7, 6, 0, 0, 14284, 14285, 7, 11, 0, 0, 14285, + 14286, 7, 15, 0, 0, 14286, 14287, 7, 4, 0, 0, 14287, 14288, 7, 17, 0, 0, + 14288, 14289, 7, 11, 0, 0, 14289, 14290, 5, 95, 0, 0, 14290, 14291, 7, + 0, 0, 0, 14291, 14292, 7, 3, 0, 0, 14292, 14293, 7, 3, 0, 0, 14293, 14294, + 7, 0, 0, 0, 14294, 14295, 7, 18, 0, 0, 14295, 14296, 5, 95, 0, 0, 14296, + 14297, 7, 13, 0, 0, 14297, 14298, 7, 3, 0, 0, 14298, 14299, 7, 0, 0, 0, + 14299, 14300, 7, 2, 0, 0, 14300, 14301, 7, 2, 0, 0, 14301, 14302, 7, 9, + 0, 0, 14302, 14303, 7, 3, 0, 0, 14303, 2046, 1, 0, 0, 0, 14304, 14305, + 7, 13, 0, 0, 14305, 14306, 7, 4, 0, 0, 14306, 14307, 7, 3, 0, 0, 14307, + 14308, 7, 22, 0, 0, 14308, 2048, 1, 0, 0, 0, 14309, 14310, 7, 13, 0, 0, + 14310, 14311, 7, 4, 0, 0, 14311, 14312, 7, 3, 0, 0, 14312, 14313, 7, 22, + 0, 0, 14313, 14314, 7, 20, 0, 0, 14314, 14315, 7, 4, 0, 0, 14315, 14316, + 7, 0, 0, 0, 14316, 14317, 7, 1, 0, 0, 14317, 2050, 1, 0, 0, 0, 14318, 14319, + 7, 13, 0, 0, 14319, 14320, 7, 3, 0, 0, 14320, 14321, 7, 6, 0, 0, 14321, + 14322, 7, 11, 0, 0, 14322, 14323, 7, 9, 0, 0, 14323, 2052, 1, 0, 0, 0, + 14324, 14325, 7, 23, 0, 0, 14325, 14326, 5, 52, 0, 0, 14326, 14327, 7, + 20, 0, 0, 14327, 14328, 7, 0, 0, 0, 14328, 14329, 7, 3, 0, 0, 14329, 14330, + 7, 21, 0, 0, 14330, 14331, 7, 9, 0, 0, 14331, 2054, 1, 0, 0, 0, 14332, + 14333, 7, 23, 0, 0, 14333, 14334, 5, 53, 0, 0, 14334, 14335, 7, 20, 0, + 0, 14335, 14336, 7, 0, 0, 0, 14336, 14337, 7, 3, 0, 0, 14337, 14338, 7, + 21, 0, 0, 14338, 14339, 7, 9, 0, 0, 14339, 2056, 1, 0, 0, 0, 14340, 14341, + 7, 23, 0, 0, 14341, 14342, 5, 54, 0, 0, 14342, 14343, 7, 20, 0, 0, 14343, + 14344, 7, 0, 0, 0, 14344, 14345, 7, 3, 0, 0, 14345, 14346, 7, 21, 0, 0, + 14346, 14347, 7, 9, 0, 0, 14347, 2058, 1, 0, 0, 0, 14348, 14349, 7, 23, + 0, 0, 14349, 14350, 7, 20, 0, 0, 14350, 14351, 7, 0, 0, 0, 14351, 14352, + 7, 3, 0, 0, 14352, 14353, 7, 21, 0, 0, 14353, 14354, 7, 9, 0, 0, 14354, + 2060, 1, 0, 0, 0, 14355, 14356, 7, 23, 0, 0, 14356, 14357, 7, 20, 0, 0, + 14357, 14358, 7, 4, 0, 0, 14358, 14359, 7, 14, 0, 0, 14359, 14360, 7, 22, + 0, 0, 14360, 2062, 1, 0, 0, 0, 14361, 14362, 7, 23, 0, 0, 14362, 14363, + 7, 19, 0, 0, 14363, 14364, 7, 20, 0, 0, 14364, 2064, 1, 0, 0, 0, 14365, + 14366, 5, 39, 0, 0, 14366, 14367, 7, 23, 0, 0, 14367, 14368, 7, 19, 0, + 0, 14368, 14369, 7, 20, 0, 0, 14369, 14370, 5, 39, 0, 0, 14370, 2066, 1, + 0, 0, 0, 14371, 14372, 7, 23, 0, 0, 14372, 14373, 7, 7, 0, 0, 14373, 14374, + 7, 19, 0, 0, 14374, 14375, 7, 0, 0, 0, 14375, 14376, 7, 20, 0, 0, 14376, + 14377, 7, 20, 0, 0, 14377, 2068, 1, 0, 0, 0, 14378, 14379, 7, 23, 0, 0, + 14379, 14380, 7, 23, 0, 0, 14380, 14381, 7, 20, 0, 0, 14381, 14382, 7, + 0, 0, 0, 14382, 14383, 7, 3, 0, 0, 14383, 14384, 7, 21, 0, 0, 14384, 14385, + 7, 9, 0, 0, 14385, 2070, 1, 0, 0, 0, 14386, 14387, 7, 23, 0, 0, 14387, + 14388, 7, 23, 0, 0, 14388, 14389, 7, 23, 0, 0, 14389, 14390, 7, 20, 0, + 0, 14390, 14391, 7, 0, 0, 0, 14391, 14392, 7, 3, 0, 0, 14392, 14393, 7, + 21, 0, 0, 14393, 14394, 7, 9, 0, 0, 14394, 2072, 1, 0, 0, 0, 14395, 14396, + 7, 18, 0, 0, 14396, 14397, 7, 9, 0, 0, 14397, 14398, 7, 0, 0, 0, 14398, + 14399, 7, 3, 0, 0, 14399, 14400, 7, 20, 0, 0, 14400, 14401, 7, 18, 0, 0, + 14401, 2074, 1, 0, 0, 0, 14402, 14403, 7, 24, 0, 0, 14403, 14404, 7, 7, + 0, 0, 14404, 14405, 7, 11, 0, 0, 14405, 14406, 7, 1, 0, 0, 14406, 2076, + 1, 0, 0, 0, 14407, 14408, 7, 0, 0, 0, 14408, 14409, 7, 3, 0, 0, 14409, + 14410, 7, 3, 0, 0, 14410, 14411, 7, 0, 0, 0, 14411, 14412, 7, 18, 0, 0, + 14412, 2078, 1, 0, 0, 0, 14413, 14414, 5, 39, 0, 0, 14414, 14415, 7, 0, + 0, 0, 14415, 14416, 7, 3, 0, 0, 14416, 14417, 7, 3, 0, 0, 14417, 14418, + 7, 0, 0, 0, 14418, 14419, 7, 18, 0, 0, 14419, 14420, 5, 39, 0, 0, 14420, + 2080, 1, 0, 0, 0, 14421, 14422, 7, 10, 0, 0, 14422, 14423, 7, 6, 0, 0, + 14423, 14424, 7, 21, 0, 0, 14424, 14425, 7, 6, 0, 0, 14425, 14426, 7, 8, + 0, 0, 14426, 14427, 7, 11, 0, 0, 14427, 2082, 1, 0, 0, 0, 14428, 14429, + 7, 10, 0, 0, 14429, 14430, 7, 6, 0, 0, 14430, 14431, 7, 8, 0, 0, 14431, + 14432, 7, 0, 0, 0, 14432, 14433, 7, 3, 0, 0, 14433, 14434, 7, 18, 0, 0, + 14434, 2084, 1, 0, 0, 0, 14435, 14436, 7, 10, 0, 0, 14436, 14437, 7, 4, + 0, 0, 14437, 14438, 7, 4, 0, 0, 14438, 14439, 7, 20, 0, 0, 14439, 14440, + 7, 9, 0, 0, 14440, 14441, 7, 0, 0, 0, 14441, 14442, 7, 8, 0, 0, 14442, + 2086, 1, 0, 0, 0, 14443, 14444, 7, 10, 0, 0, 14444, 14445, 7, 18, 0, 0, + 14445, 14446, 7, 11, 0, 0, 14446, 14447, 7, 9, 0, 0, 14447, 14448, 7, 6, + 0, 0, 14448, 14449, 7, 8, 0, 0, 14449, 14450, 7, 11, 0, 0, 14450, 2088, + 1, 0, 0, 0, 14451, 14452, 7, 14, 0, 0, 14452, 14453, 7, 15, 0, 0, 14453, + 14454, 7, 0, 0, 0, 14454, 14455, 7, 3, 0, 0, 14455, 14456, 5, 32, 0, 0, + 14456, 14457, 7, 5, 0, 0, 14457, 14458, 7, 0, 0, 0, 14458, 14459, 7, 3, + 0, 0, 14459, 14460, 7, 18, 0, 0, 14460, 14461, 7, 6, 0, 0, 14461, 14462, + 7, 8, 0, 0, 14462, 14463, 7, 21, 0, 0, 14463, 2090, 1, 0, 0, 0, 14464, + 14465, 7, 1, 0, 0, 14465, 14466, 7, 0, 0, 0, 14466, 14467, 7, 11, 0, 0, + 14467, 14468, 7, 9, 0, 0, 14468, 2092, 1, 0, 0, 0, 14469, 14470, 7, 1, + 0, 0, 14470, 14471, 7, 0, 0, 0, 14471, 14472, 7, 11, 0, 0, 14472, 14473, + 7, 9, 0, 0, 14473, 14474, 7, 11, 0, 0, 14474, 14475, 7, 6, 0, 0, 14475, + 14476, 7, 19, 0, 0, 14476, 14477, 7, 9, 0, 0, 14477, 2094, 1, 0, 0, 0, + 14478, 14479, 7, 1, 0, 0, 14479, 14480, 7, 9, 0, 0, 14480, 14481, 7, 14, + 0, 0, 14481, 14482, 7, 6, 0, 0, 14482, 14483, 7, 19, 0, 0, 14483, 14484, + 7, 0, 0, 0, 14484, 14485, 7, 20, 0, 0, 14485, 2096, 1, 0, 0, 0, 14486, + 14487, 7, 12, 0, 0, 14487, 14488, 7, 20, 0, 0, 14488, 14489, 7, 4, 0, 0, + 14489, 14490, 7, 0, 0, 0, 14490, 14491, 7, 11, 0, 0, 14491, 14492, 5, 52, + 0, 0, 14492, 2098, 1, 0, 0, 0, 14493, 14494, 7, 12, 0, 0, 14494, 14495, + 7, 20, 0, 0, 14495, 14496, 7, 4, 0, 0, 14496, 14497, 7, 0, 0, 0, 14497, + 14498, 7, 11, 0, 0, 14498, 14499, 5, 56, 0, 0, 14499, 2100, 1, 0, 0, 0, + 14500, 14501, 7, 12, 0, 0, 14501, 14502, 7, 20, 0, 0, 14502, 14503, 7, + 4, 0, 0, 14503, 14504, 7, 0, 0, 0, 14504, 14505, 7, 11, 0, 0, 14505, 2102, + 1, 0, 0, 0, 14506, 14507, 7, 21, 0, 0, 14507, 14508, 7, 9, 0, 0, 14508, + 14509, 7, 4, 0, 0, 14509, 14510, 7, 21, 0, 0, 14510, 14511, 7, 3, 0, 0, + 14511, 14512, 7, 0, 0, 0, 14512, 14513, 7, 2, 0, 0, 14513, 14514, 7, 15, + 0, 0, 14514, 14515, 7, 18, 0, 0, 14515, 2104, 1, 0, 0, 0, 14516, 14517, + 7, 21, 0, 0, 14517, 14518, 7, 9, 0, 0, 14518, 14519, 7, 4, 0, 0, 14519, + 14520, 7, 19, 0, 0, 14520, 14521, 7, 9, 0, 0, 14521, 14522, 7, 11, 0, 0, + 14522, 14523, 7, 3, 0, 0, 14523, 14524, 7, 18, 0, 0, 14524, 2106, 1, 0, + 0, 0, 14525, 14526, 7, 6, 0, 0, 14526, 14527, 7, 8, 0, 0, 14527, 14528, + 7, 11, 0, 0, 14528, 14529, 7, 9, 0, 0, 14529, 14530, 7, 21, 0, 0, 14530, + 14531, 7, 9, 0, 0, 14531, 14532, 7, 3, 0, 0, 14532, 2108, 1, 0, 0, 0, 14533, + 14534, 7, 8, 0, 0, 14534, 14535, 7, 14, 0, 0, 14535, 14536, 7, 15, 0, 0, + 14536, 14537, 7, 0, 0, 0, 14537, 14538, 7, 3, 0, 0, 14538, 14539, 5, 32, + 0, 0, 14539, 14540, 7, 5, 0, 0, 14540, 14541, 7, 0, 0, 0, 14541, 14542, + 7, 3, 0, 0, 14542, 14543, 7, 18, 0, 0, 14543, 14544, 7, 6, 0, 0, 14544, + 14545, 7, 8, 0, 0, 14545, 14546, 7, 21, 0, 0, 14546, 2110, 1, 0, 0, 0, + 14547, 14548, 7, 8, 0, 0, 14548, 14549, 7, 17, 0, 0, 14549, 14550, 7, 19, + 0, 0, 14550, 14551, 7, 9, 0, 0, 14551, 14552, 7, 3, 0, 0, 14552, 14553, + 7, 6, 0, 0, 14553, 14554, 7, 14, 0, 0, 14554, 2112, 1, 0, 0, 0, 14555, + 14556, 7, 8, 0, 0, 14556, 14557, 7, 5, 0, 0, 14557, 14558, 7, 0, 0, 0, + 14558, 14559, 7, 3, 0, 0, 14559, 14560, 7, 14, 0, 0, 14560, 14561, 7, 15, + 0, 0, 14561, 14562, 7, 0, 0, 0, 14562, 14563, 7, 3, 0, 0, 14563, 14564, + 5, 50, 0, 0, 14564, 2114, 1, 0, 0, 0, 14565, 14566, 7, 8, 0, 0, 14566, + 14567, 7, 5, 0, 0, 14567, 14568, 7, 0, 0, 0, 14568, 14569, 7, 3, 0, 0, + 14569, 14570, 7, 14, 0, 0, 14570, 14571, 7, 15, 0, 0, 14571, 14572, 7, + 0, 0, 0, 14572, 14573, 7, 3, 0, 0, 14573, 2116, 1, 0, 0, 0, 14574, 14575, + 7, 3, 0, 0, 14575, 14576, 7, 9, 0, 0, 14576, 14577, 7, 0, 0, 0, 14577, + 14578, 7, 20, 0, 0, 14578, 2118, 1, 0, 0, 0, 14579, 14580, 7, 7, 0, 0, + 14580, 14581, 7, 19, 0, 0, 14581, 14582, 7, 0, 0, 0, 14582, 14583, 7, 20, + 0, 0, 14583, 14584, 7, 20, 0, 0, 14584, 14585, 7, 6, 0, 0, 14585, 14586, + 7, 8, 0, 0, 14586, 14587, 7, 11, 0, 0, 14587, 2120, 1, 0, 0, 0, 14588, + 14589, 7, 7, 0, 0, 14589, 14590, 7, 11, 0, 0, 14590, 14591, 7, 3, 0, 0, + 14591, 14592, 7, 6, 0, 0, 14592, 14593, 7, 8, 0, 0, 14593, 14594, 7, 21, + 0, 0, 14594, 2122, 1, 0, 0, 0, 14595, 14596, 7, 11, 0, 0, 14596, 14597, + 7, 9, 0, 0, 14597, 14598, 7, 23, 0, 0, 14598, 14599, 7, 11, 0, 0, 14599, + 2124, 1, 0, 0, 0, 14600, 14601, 7, 11, 0, 0, 14601, 14602, 7, 6, 0, 0, + 14602, 14603, 7, 8, 0, 0, 14603, 14604, 7, 18, 0, 0, 14604, 14605, 7, 6, + 0, 0, 14605, 14606, 7, 8, 0, 0, 14606, 14607, 7, 11, 0, 0, 14607, 2126, + 1, 0, 0, 0, 14608, 14609, 7, 5, 0, 0, 14609, 14610, 7, 0, 0, 0, 14610, + 14611, 7, 3, 0, 0, 14611, 14612, 7, 10, 0, 0, 14612, 14613, 7, 6, 0, 0, + 14613, 14614, 7, 8, 0, 0, 14614, 14615, 7, 0, 0, 0, 14615, 14616, 7, 3, + 0, 0, 14616, 14617, 7, 18, 0, 0, 14617, 2128, 1, 0, 0, 0, 14618, 14619, + 7, 5, 0, 0, 14619, 14620, 7, 0, 0, 0, 14620, 14621, 7, 3, 0, 0, 14621, + 14622, 7, 14, 0, 0, 14622, 14623, 7, 15, 0, 0, 14623, 14624, 7, 0, 0, 0, + 14624, 14625, 7, 3, 0, 0, 14625, 2130, 1, 0, 0, 0, 14626, 14627, 7, 5, + 0, 0, 14627, 14628, 7, 0, 0, 0, 14628, 14629, 7, 3, 0, 0, 14629, 14630, + 7, 6, 0, 0, 14630, 14631, 7, 0, 0, 0, 14631, 14632, 7, 8, 0, 0, 14632, + 14633, 7, 11, 0, 0, 14633, 2132, 1, 0, 0, 0, 14634, 14635, 7, 20, 0, 0, + 14635, 14636, 7, 6, 0, 0, 14636, 14637, 7, 7, 0, 0, 14637, 14638, 7, 11, + 0, 0, 14638, 14639, 7, 0, 0, 0, 14639, 14640, 7, 21, 0, 0, 14640, 14641, + 7, 21, 0, 0, 14641, 2134, 1, 0, 0, 0, 14642, 14643, 7, 1, 0, 0, 14643, + 14644, 7, 17, 0, 0, 14644, 14645, 7, 19, 0, 0, 14645, 14646, 7, 19, 0, + 0, 14646, 14647, 7, 18, 0, 0, 14647, 2136, 1, 0, 0, 0, 14648, 14650, 7, + 26, 0, 0, 14649, 14648, 1, 0, 0, 0, 14650, 14651, 1, 0, 0, 0, 14651, 14649, + 1, 0, 0, 0, 14651, 14652, 1, 0, 0, 0, 14652, 14653, 1, 0, 0, 0, 14653, + 14654, 6, 1068, 0, 0, 14654, 2138, 1, 0, 0, 0, 14655, 14656, 5, 47, 0, + 0, 14656, 14657, 5, 42, 0, 0, 14657, 14662, 1, 0, 0, 0, 14658, 14661, 3, + 2139, 1069, 0, 14659, 14661, 9, 0, 0, 0, 14660, 14658, 1, 0, 0, 0, 14660, + 14659, 1, 0, 0, 0, 14661, 14664, 1, 0, 0, 0, 14662, 14663, 1, 0, 0, 0, + 14662, 14660, 1, 0, 0, 0, 14663, 14665, 1, 0, 0, 0, 14664, 14662, 1, 0, + 0, 0, 14665, 14666, 5, 42, 0, 0, 14666, 14667, 5, 47, 0, 0, 14667, 14668, + 1, 0, 0, 0, 14668, 14669, 6, 1069, 0, 0, 14669, 2140, 1, 0, 0, 0, 14670, + 14671, 5, 45, 0, 0, 14671, 14672, 5, 45, 0, 0, 14672, 14676, 1, 0, 0, 0, + 14673, 14675, 8, 27, 0, 0, 14674, 14673, 1, 0, 0, 0, 14675, 14678, 1, 0, + 0, 0, 14676, 14674, 1, 0, 0, 0, 14676, 14677, 1, 0, 0, 0, 14677, 14679, + 1, 0, 0, 0, 14678, 14676, 1, 0, 0, 0, 14679, 14680, 6, 1070, 0, 0, 14680, + 2142, 1, 0, 0, 0, 14681, 14682, 5, 47, 0, 0, 14682, 14683, 5, 47, 0, 0, + 14683, 14687, 1, 0, 0, 0, 14684, 14686, 8, 27, 0, 0, 14685, 14684, 1, 0, + 0, 0, 14686, 14689, 1, 0, 0, 0, 14687, 14685, 1, 0, 0, 0, 14687, 14688, + 1, 0, 0, 0, 14688, 14690, 1, 0, 0, 0, 14689, 14687, 1, 0, 0, 0, 14690, + 14691, 6, 1071, 0, 0, 14691, 2144, 1, 0, 0, 0, 14692, 14694, 5, 34, 0, + 0, 14693, 14695, 8, 28, 0, 0, 14694, 14693, 1, 0, 0, 0, 14695, 14696, 1, + 0, 0, 0, 14696, 14694, 1, 0, 0, 0, 14696, 14697, 1, 0, 0, 0, 14697, 14698, + 1, 0, 0, 0, 14698, 14699, 5, 34, 0, 0, 14699, 2146, 1, 0, 0, 0, 14700, + 14701, 5, 34, 0, 0, 14701, 14702, 5, 34, 0, 0, 14702, 2148, 1, 0, 0, 0, + 14703, 14704, 5, 39, 0, 0, 14704, 2150, 1, 0, 0, 0, 14705, 14709, 7, 29, + 0, 0, 14706, 14708, 7, 30, 0, 0, 14707, 14706, 1, 0, 0, 0, 14708, 14711, + 1, 0, 0, 0, 14709, 14707, 1, 0, 0, 0, 14709, 14710, 1, 0, 0, 0, 14710, + 2152, 1, 0, 0, 0, 14711, 14709, 1, 0, 0, 0, 14712, 14713, 5, 36, 0, 0, + 14713, 14717, 7, 29, 0, 0, 14714, 14716, 7, 31, 0, 0, 14715, 14714, 1, + 0, 0, 0, 14716, 14719, 1, 0, 0, 0, 14717, 14715, 1, 0, 0, 0, 14717, 14718, + 1, 0, 0, 0, 14718, 2154, 1, 0, 0, 0, 14719, 14717, 1, 0, 0, 0, 14720, 14721, + 5, 39, 0, 0, 14721, 14722, 7, 7, 0, 0, 14722, 14723, 5, 51, 0, 0, 14723, + 14724, 5, 58, 0, 0, 14724, 14725, 5, 47, 0, 0, 14725, 14726, 5, 47, 0, + 0, 14726, 14727, 5, 39, 0, 0, 14727, 2156, 1, 0, 0, 0, 14728, 14729, 5, + 39, 0, 0, 14729, 14730, 7, 21, 0, 0, 14730, 14731, 7, 14, 0, 0, 14731, + 14732, 7, 7, 0, 0, 14732, 14733, 5, 58, 0, 0, 14733, 14734, 5, 47, 0, 0, + 14734, 14735, 5, 47, 0, 0, 14735, 14736, 5, 39, 0, 0, 14736, 2158, 1, 0, + 0, 0, 14737, 14738, 5, 39, 0, 0, 14738, 14739, 7, 0, 0, 0, 14739, 14740, + 7, 24, 0, 0, 14740, 14741, 7, 17, 0, 0, 14741, 14742, 7, 3, 0, 0, 14742, + 14743, 7, 9, 0, 0, 14743, 14744, 5, 58, 0, 0, 14744, 14745, 5, 47, 0, 0, + 14745, 14746, 5, 47, 0, 0, 14746, 14747, 5, 39, 0, 0, 14747, 2160, 1, 0, + 0, 0, 14748, 14749, 7, 12, 0, 0, 14749, 14750, 7, 6, 0, 0, 14750, 14751, + 7, 20, 0, 0, 14751, 14752, 7, 9, 0, 0, 14752, 14753, 5, 58, 0, 0, 14753, + 14754, 5, 47, 0, 0, 14754, 14755, 5, 47, 0, 0, 14755, 2162, 1, 0, 0, 0, + 14756, 14757, 5, 36, 0, 0, 14757, 14758, 5, 36, 0, 0, 14758, 14764, 1, + 0, 0, 0, 14759, 14763, 8, 32, 0, 0, 14760, 14761, 5, 92, 0, 0, 14761, 14763, + 5, 36, 0, 0, 14762, 14759, 1, 0, 0, 0, 14762, 14760, 1, 0, 0, 0, 14763, + 14766, 1, 0, 0, 0, 14764, 14765, 1, 0, 0, 0, 14764, 14762, 1, 0, 0, 0, + 14765, 14767, 1, 0, 0, 0, 14766, 14764, 1, 0, 0, 0, 14767, 14768, 5, 36, + 0, 0, 14768, 14769, 5, 36, 0, 0, 14769, 2164, 1, 0, 0, 0, 14770, 14776, + 5, 39, 0, 0, 14771, 14775, 8, 33, 0, 0, 14772, 14773, 5, 39, 0, 0, 14773, + 14775, 5, 39, 0, 0, 14774, 14771, 1, 0, 0, 0, 14774, 14772, 1, 0, 0, 0, + 14775, 14778, 1, 0, 0, 0, 14776, 14774, 1, 0, 0, 0, 14776, 14777, 1, 0, + 0, 0, 14777, 14779, 1, 0, 0, 0, 14778, 14776, 1, 0, 0, 0, 14779, 14780, + 5, 39, 0, 0, 14780, 2166, 1, 0, 0, 0, 14781, 14783, 3, 2247, 1123, 0, 14782, + 14781, 1, 0, 0, 0, 14783, 14784, 1, 0, 0, 0, 14784, 14782, 1, 0, 0, 0, + 14784, 14785, 1, 0, 0, 0, 14785, 2168, 1, 0, 0, 0, 14786, 14787, 3, 2245, + 1122, 0, 14787, 2170, 1, 0, 0, 0, 14788, 14791, 3, 2167, 1083, 0, 14789, + 14791, 3, 2245, 1122, 0, 14790, 14788, 1, 0, 0, 0, 14790, 14789, 1, 0, + 0, 0, 14791, 14792, 1, 0, 0, 0, 14792, 14794, 7, 9, 0, 0, 14793, 14795, + 7, 34, 0, 0, 14794, 14793, 1, 0, 0, 0, 14794, 14795, 1, 0, 0, 0, 14795, + 14797, 1, 0, 0, 0, 14796, 14798, 3, 2247, 1123, 0, 14797, 14796, 1, 0, + 0, 0, 14798, 14799, 1, 0, 0, 0, 14799, 14797, 1, 0, 0, 0, 14799, 14800, + 1, 0, 0, 0, 14800, 2172, 1, 0, 0, 0, 14801, 14804, 5, 39, 0, 0, 14802, + 14805, 8, 35, 0, 0, 14803, 14805, 3, 2175, 1087, 0, 14804, 14802, 1, 0, + 0, 0, 14804, 14803, 1, 0, 0, 0, 14805, 14806, 1, 0, 0, 0, 14806, 14807, + 5, 39, 0, 0, 14807, 2174, 1, 0, 0, 0, 14808, 14809, 5, 92, 0, 0, 14809, + 14830, 7, 36, 0, 0, 14810, 14815, 5, 92, 0, 0, 14811, 14813, 7, 37, 0, + 0, 14812, 14811, 1, 0, 0, 0, 14812, 14813, 1, 0, 0, 0, 14813, 14814, 1, + 0, 0, 0, 14814, 14816, 7, 38, 0, 0, 14815, 14812, 1, 0, 0, 0, 14815, 14816, + 1, 0, 0, 0, 14816, 14817, 1, 0, 0, 0, 14817, 14830, 7, 38, 0, 0, 14818, + 14820, 5, 92, 0, 0, 14819, 14821, 7, 17, 0, 0, 14820, 14819, 1, 0, 0, 0, + 14821, 14822, 1, 0, 0, 0, 14822, 14820, 1, 0, 0, 0, 14822, 14823, 1, 0, + 0, 0, 14823, 14824, 1, 0, 0, 0, 14824, 14825, 3, 2177, 1088, 0, 14825, + 14826, 3, 2177, 1088, 0, 14826, 14827, 3, 2177, 1088, 0, 14827, 14828, + 3, 2177, 1088, 0, 14828, 14830, 1, 0, 0, 0, 14829, 14808, 1, 0, 0, 0, 14829, + 14810, 1, 0, 0, 0, 14829, 14818, 1, 0, 0, 0, 14830, 2176, 1, 0, 0, 0, 14831, + 14832, 7, 39, 0, 0, 14832, 2178, 1, 0, 0, 0, 14833, 14834, 5, 45, 0, 0, + 14834, 14835, 5, 62, 0, 0, 14835, 2180, 1, 0, 0, 0, 14836, 14837, 5, 61, + 0, 0, 14837, 14838, 5, 62, 0, 0, 14838, 2182, 1, 0, 0, 0, 14839, 14840, + 5, 33, 0, 0, 14840, 14841, 5, 61, 0, 0, 14841, 2184, 1, 0, 0, 0, 14842, + 14843, 5, 60, 0, 0, 14843, 14844, 5, 62, 0, 0, 14844, 2186, 1, 0, 0, 0, + 14845, 14846, 5, 61, 0, 0, 14846, 2188, 1, 0, 0, 0, 14847, 14848, 5, 62, + 0, 0, 14848, 2190, 1, 0, 0, 0, 14849, 14850, 5, 62, 0, 0, 14850, 14851, + 5, 61, 0, 0, 14851, 2192, 1, 0, 0, 0, 14852, 14853, 5, 60, 0, 0, 14853, + 2194, 1, 0, 0, 0, 14854, 14855, 5, 60, 0, 0, 14855, 14856, 5, 61, 0, 0, + 14856, 2196, 1, 0, 0, 0, 14857, 14858, 5, 33, 0, 0, 14858, 2198, 1, 0, + 0, 0, 14859, 14860, 5, 124, 0, 0, 14860, 14861, 5, 124, 0, 0, 14861, 2200, + 1, 0, 0, 0, 14862, 14863, 5, 46, 0, 0, 14863, 2202, 1, 0, 0, 0, 14864, + 14865, 5, 95, 0, 0, 14865, 2204, 1, 0, 0, 0, 14866, 14867, 5, 64, 0, 0, + 14867, 2206, 1, 0, 0, 0, 14868, 14869, 5, 39, 0, 0, 14869, 14870, 5, 64, + 0, 0, 14870, 14871, 5, 39, 0, 0, 14871, 2208, 1, 0, 0, 0, 14872, 14873, + 5, 36, 0, 0, 14873, 2210, 1, 0, 0, 0, 14874, 14875, 5, 40, 0, 0, 14875, + 2212, 1, 0, 0, 0, 14876, 14877, 5, 41, 0, 0, 14877, 2214, 1, 0, 0, 0, 14878, + 14879, 5, 91, 0, 0, 14879, 2216, 1, 0, 0, 0, 14880, 14881, 5, 93, 0, 0, + 14881, 2218, 1, 0, 0, 0, 14882, 14883, 5, 123, 0, 0, 14883, 2220, 1, 0, + 0, 0, 14884, 14885, 5, 125, 0, 0, 14885, 2222, 1, 0, 0, 0, 14886, 14887, + 5, 44, 0, 0, 14887, 2224, 1, 0, 0, 0, 14888, 14889, 5, 59, 0, 0, 14889, + 2226, 1, 0, 0, 0, 14890, 14891, 5, 58, 0, 0, 14891, 2228, 1, 0, 0, 0, 14892, + 14893, 5, 58, 0, 0, 14893, 14894, 5, 58, 0, 0, 14894, 2230, 1, 0, 0, 0, + 14895, 14896, 5, 42, 0, 0, 14896, 2232, 1, 0, 0, 0, 14897, 14898, 5, 47, + 0, 0, 14898, 2234, 1, 0, 0, 0, 14899, 14900, 5, 37, 0, 0, 14900, 2236, + 1, 0, 0, 0, 14901, 14902, 5, 43, 0, 0, 14902, 2238, 1, 0, 0, 0, 14903, + 14904, 5, 45, 0, 0, 14904, 2240, 1, 0, 0, 0, 14905, 14906, 5, 63, 0, 0, + 14906, 2242, 1, 0, 0, 0, 14907, 14908, 7, 29, 0, 0, 14908, 2244, 1, 0, + 0, 0, 14909, 14911, 3, 2247, 1123, 0, 14910, 14909, 1, 0, 0, 0, 14911, + 14912, 1, 0, 0, 0, 14912, 14910, 1, 0, 0, 0, 14912, 14913, 1, 0, 0, 0, + 14913, 14914, 1, 0, 0, 0, 14914, 14916, 5, 46, 0, 0, 14915, 14917, 3, 2247, + 1123, 0, 14916, 14915, 1, 0, 0, 0, 14917, 14918, 1, 0, 0, 0, 14918, 14916, + 1, 0, 0, 0, 14918, 14919, 1, 0, 0, 0, 14919, 14934, 1, 0, 0, 0, 14920, + 14922, 3, 2247, 1123, 0, 14921, 14920, 1, 0, 0, 0, 14922, 14923, 1, 0, + 0, 0, 14923, 14921, 1, 0, 0, 0, 14923, 14924, 1, 0, 0, 0, 14924, 14925, + 1, 0, 0, 0, 14925, 14926, 5, 46, 0, 0, 14926, 14934, 1, 0, 0, 0, 14927, + 14929, 5, 46, 0, 0, 14928, 14930, 3, 2247, 1123, 0, 14929, 14928, 1, 0, + 0, 0, 14930, 14931, 1, 0, 0, 0, 14931, 14929, 1, 0, 0, 0, 14931, 14932, + 1, 0, 0, 0, 14932, 14934, 1, 0, 0, 0, 14933, 14910, 1, 0, 0, 0, 14933, + 14921, 1, 0, 0, 0, 14933, 14927, 1, 0, 0, 0, 14934, 2246, 1, 0, 0, 0, 14935, + 14936, 7, 40, 0, 0, 14936, 2248, 1, 0, 0, 0, 14937, 14938, 7, 41, 0, 0, + 14938, 2250, 1, 0, 0, 0, 30, 0, 5754, 10709, 11850, 14651, 14660, 14662, + 14676, 14687, 14696, 14709, 14717, 14762, 14764, 14774, 14776, 14784, 14790, + 14794, 14799, 14804, 14812, 14815, 14822, 14829, 14912, 14918, 14923, 14931, + 14933, 1, 0, 1, 0, + } + 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) + } +} + +// SnowflakeLexerInit initializes any static state used to implement SnowflakeLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewSnowflakeLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func SnowflakeLexerInit() { + staticData := &SnowflakeLexerLexerStaticData + staticData.once.Do(snowflakelexerLexerInit) +} + +// NewSnowflakeLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewSnowflakeLexer(input antlr.CharStream) *SnowflakeLexer { + SnowflakeLexerInit() + l := new(SnowflakeLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &SnowflakeLexerLexerStaticData + l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.PredictionContextCache) + l.channelNames = staticData.ChannelNames + l.modeNames = staticData.ModeNames + l.RuleNames = staticData.RuleNames + l.LiteralNames = staticData.LiteralNames + l.SymbolicNames = staticData.SymbolicNames + l.GrammarFileName = "SnowflakeLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// SnowflakeLexer tokens. +const ( + SnowflakeLexerAAD_PROVISIONER_Q = 1 + SnowflakeLexerABORT = 2 + SnowflakeLexerABORT_AFTER_WAIT = 3 + SnowflakeLexerABORT_DETACHED_QUERY = 4 + SnowflakeLexerABORT_STATEMENT = 5 + SnowflakeLexerABSENT = 6 + SnowflakeLexerABSOLUTE = 7 + SnowflakeLexerACCESS = 8 + SnowflakeLexerACCOUNT = 9 + SnowflakeLexerACCOUNTADMIN = 10 + SnowflakeLexerACCOUNTS = 11 + SnowflakeLexerACTION = 12 + SnowflakeLexerACTIVE = 13 + SnowflakeLexerADD = 14 + SnowflakeLexerADMINISTER = 15 + SnowflakeLexerADMIN_NAME = 16 + SnowflakeLexerADMIN_PASSWORD = 17 + SnowflakeLexerAES = 18 + SnowflakeLexerAFTER = 19 + SnowflakeLexerAGGREGATE = 20 + SnowflakeLexerALERT = 21 + SnowflakeLexerALERTS = 22 + SnowflakeLexerALL = 23 + SnowflakeLexerALLOWED = 24 + SnowflakeLexerALLOWED_ACCOUNTS = 25 + SnowflakeLexerALLOWED_DATABASES = 26 + SnowflakeLexerALLOWED_INTEGRATION_TYPES = 27 + SnowflakeLexerALLOWED_IP_LIST = 28 + SnowflakeLexerALLOWED_SHARES = 29 + SnowflakeLexerALLOWED_VALUES = 30 + SnowflakeLexerALLOW_CLIENT_MFA_CACHING = 31 + SnowflakeLexerALLOW_CONNECTIONS = 32 + SnowflakeLexerALLOW_DUPLICATE = 33 + SnowflakeLexerALLOW_ID_TOKEN = 34 + SnowflakeLexerALLOW_MULTIPLE_EVENT_LOSS = 35 + SnowflakeLexerALLOW_OVERLAPPING_EXECUTION = 36 + SnowflakeLexerALLOW_SINGLE_EVENT_LOSS = 37 + SnowflakeLexerALTER = 38 + SnowflakeLexerALWAYS = 39 + SnowflakeLexerAND = 40 + SnowflakeLexerANONYMOUS = 41 + SnowflakeLexerANSI_DEFAULTS = 42 + SnowflakeLexerANY = 43 + SnowflakeLexerAPI = 44 + SnowflakeLexerAPI_ALLOWED_PREFIXES = 45 + SnowflakeLexerAPI_AWS_ROLE_ARN = 46 + SnowflakeLexerAPI_BLOCKED_PREFIXES = 47 + SnowflakeLexerAPI_INTEGRATION = 48 + SnowflakeLexerAPI_KEY = 49 + SnowflakeLexerAPI_PROVIDER = 50 + SnowflakeLexerAPPEND = 51 + SnowflakeLexerAPPEND_ONLY = 52 + SnowflakeLexerAPPLICATION = 53 + SnowflakeLexerAPPLY = 54 + SnowflakeLexerAPP_NAME = 55 + SnowflakeLexerAS = 56 + SnowflakeLexerASC = 57 + SnowflakeLexerATTACH = 58 + SnowflakeLexerAT_KEYWORD = 59 + SnowflakeLexerAUTHORIZATION = 60 + SnowflakeLexerAUTHORIZATIONS = 61 + SnowflakeLexerAUTO = 62 + SnowflakeLexerAUTO_Q = 63 + SnowflakeLexerAUTOCOMMIT = 64 + SnowflakeLexerAUTOCOMMIT_API_SUPPORTED = 65 + SnowflakeLexerAUTOINCREMENT = 66 + SnowflakeLexerAUTO_COMPRESS = 67 + SnowflakeLexerAUTO_DETECT = 68 + SnowflakeLexerAUTO_INGEST = 69 + SnowflakeLexerAUTO_REFRESH = 70 + SnowflakeLexerAUTO_RESUME = 71 + SnowflakeLexerAUTO_SUSPEND = 72 + SnowflakeLexerAVG = 73 + SnowflakeLexerAVRO = 74 + SnowflakeLexerAVRO_Q = 75 + SnowflakeLexerAWS_KEY_ID = 76 + SnowflakeLexerAWS_ROLE = 77 + SnowflakeLexerAWS_SECRET_KEY = 78 + SnowflakeLexerAWS_SNS = 79 + SnowflakeLexerAWS_SNS_ROLE_ARN = 80 + SnowflakeLexerAWS_SNS_TOPIC = 81 + SnowflakeLexerAWS_SNS_TOPIC_ARN = 82 + SnowflakeLexerAWS_TOKEN = 83 + SnowflakeLexerAZURE = 84 + SnowflakeLexerAZURE_AD_APPLICATION_ID = 85 + SnowflakeLexerAZURE_EVENT_GRID = 86 + SnowflakeLexerAZURE_EVENT_GRID_TOPIC_ENDPOINT = 87 + SnowflakeLexerAZURE_Q = 88 + SnowflakeLexerAZURE_SAS_TOKEN = 89 + SnowflakeLexerAZURE_STORAGE_QUEUE_PRIMARY_URI = 90 + SnowflakeLexerAZURE_TENANT_ID = 91 + SnowflakeLexerBASE64 = 92 + SnowflakeLexerBEFORE = 93 + SnowflakeLexerBEGIN = 94 + SnowflakeLexerBERNOULLI = 95 + SnowflakeLexerBETWEEN = 96 + SnowflakeLexerBINARY_AS_TEXT = 97 + SnowflakeLexerBINARY_CHECKSUM = 98 + SnowflakeLexerBINARY_FORMAT = 99 + SnowflakeLexerBINARY_INPUT_FORMAT = 100 + SnowflakeLexerBINARY_OUTPUT_FORMAT = 101 + SnowflakeLexerBINDING = 102 + SnowflakeLexerBLOCK = 103 + SnowflakeLexerBLOCKED_IP_LIST = 104 + SnowflakeLexerBLOCKED_ROLES_LIST = 105 + SnowflakeLexerBODY = 106 + SnowflakeLexerBOTH_Q = 107 + SnowflakeLexerBROTLI = 108 + SnowflakeLexerBUSINESS_CRITICAL = 109 + SnowflakeLexerBY = 110 + SnowflakeLexerBZ2 = 111 + SnowflakeLexerCACHE = 112 + SnowflakeLexerCALL = 113 + SnowflakeLexerCALLED = 114 + SnowflakeLexerCALLER = 115 + SnowflakeLexerCASCADE = 116 + SnowflakeLexerCASE = 117 + SnowflakeLexerCASE_INSENSITIVE = 118 + SnowflakeLexerCASE_SENSITIVE = 119 + SnowflakeLexerCAST = 120 + SnowflakeLexerCATCH = 121 + SnowflakeLexerCERTIFICATE = 122 + SnowflakeLexerCHANGE = 123 + SnowflakeLexerCHANGES = 124 + SnowflakeLexerCHANGETABLE = 125 + SnowflakeLexerCHANGE_RETENTION = 126 + SnowflakeLexerCHANGE_TRACKING = 127 + SnowflakeLexerCHAR = 128 + SnowflakeLexerCHARACTER = 129 + SnowflakeLexerCHARINDEX = 130 + SnowflakeLexerCHECK = 131 + SnowflakeLexerCHECKSUM = 132 + SnowflakeLexerCHECKSUM_AGG = 133 + SnowflakeLexerCHECK_EXPIRATION = 134 + SnowflakeLexerCHECK_POLICY = 135 + SnowflakeLexerCLASSIFIER_FUNCTION = 136 + SnowflakeLexerCLEANUP = 137 + SnowflakeLexerCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS = 138 + SnowflakeLexerCLIENT_ENCRYPTION_KEY_SIZE = 139 + SnowflakeLexerCLIENT_MEMORY_LIMIT = 140 + SnowflakeLexerCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX = 141 + SnowflakeLexerCLIENT_METADATA_USE_SESSION_DATABASE = 142 + SnowflakeLexerCLIENT_PREFETCH_THREADS = 143 + SnowflakeLexerCLIENT_RESULT_CHUNK_SIZE = 144 + SnowflakeLexerCLIENT_RESULT_COLUMN_CASE_INSENSITIVE = 145 + SnowflakeLexerCLIENT_SESSION_KEEP_ALIVE = 146 + SnowflakeLexerCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY = 147 + SnowflakeLexerCLIENT_TIMESTAMP_TYPE_MAPPING = 148 + SnowflakeLexerCLONE = 149 + SnowflakeLexerCLOSE = 150 + SnowflakeLexerCLUSTER = 151 + SnowflakeLexerCLUSTERED = 152 + SnowflakeLexerCLUSTERING = 153 + SnowflakeLexerCOALESCE = 154 + SnowflakeLexerCOLLATE = 155 + SnowflakeLexerCOLLECTION = 156 + SnowflakeLexerCOLUMN = 157 + SnowflakeLexerCOLUMNS = 158 + SnowflakeLexerCOL_LENGTH = 159 + SnowflakeLexerCOL_NAME = 160 + SnowflakeLexerCOMMENT = 161 + SnowflakeLexerCOMMIT = 162 + SnowflakeLexerCOMMITTED = 163 + SnowflakeLexerCOMPRESS = 164 + SnowflakeLexerCOMPRESSION = 165 + SnowflakeLexerCONCAT = 166 + SnowflakeLexerCONCAT_NULL_YIELDS_NULL = 167 + SnowflakeLexerCONCAT_WS = 168 + SnowflakeLexerCONDITION = 169 + SnowflakeLexerCONFIGURATION = 170 + SnowflakeLexerCONNECT = 171 + SnowflakeLexerCONNECTION = 172 + SnowflakeLexerCONNECTIONS = 173 + SnowflakeLexerCONSTRAINT = 174 + SnowflakeLexerCONTAINMENT = 175 + SnowflakeLexerCONTAINS = 176 + SnowflakeLexerCONTENT = 177 + SnowflakeLexerCONTEXT = 178 + SnowflakeLexerCONTEXT_HEADERS = 179 + SnowflakeLexerCONTEXT_INFO = 180 + SnowflakeLexerCONTINUE = 181 + SnowflakeLexerCONTROL = 182 + SnowflakeLexerCONVERSATION = 183 + SnowflakeLexerCOOKIE = 184 + SnowflakeLexerCOPY = 185 + SnowflakeLexerCOPY_ONLY = 186 + SnowflakeLexerCOPY_OPTIONS_ = 187 + SnowflakeLexerCOUNT = 188 + SnowflakeLexerCOUNT_BIG = 189 + SnowflakeLexerCREATE = 190 + SnowflakeLexerCREDENTIALS = 191 + SnowflakeLexerCREDIT_QUOTA = 192 + SnowflakeLexerCROSS = 193 + SnowflakeLexerCSV = 194 + SnowflakeLexerCSV_Q = 195 + SnowflakeLexerCUBE = 196 + SnowflakeLexerCUME_DIST = 197 + SnowflakeLexerCURRENT = 198 + SnowflakeLexerCURRENT_DATE = 199 + SnowflakeLexerCURRENT_TIME = 200 + SnowflakeLexerCURRENT_TIMESTAMP = 201 + SnowflakeLexerCURRENT_USER = 202 + SnowflakeLexerCURSOR = 203 + SnowflakeLexerCUSTOM = 204 + SnowflakeLexerDAILY = 205 + SnowflakeLexerDATA = 206 + SnowflakeLexerDATABASE = 207 + SnowflakeLexerDATABASES = 208 + SnowflakeLexerDATA_RETENTION_TIME_IN_DAYS = 209 + SnowflakeLexerDATEADD = 210 + SnowflakeLexerDATEDIFF = 211 + SnowflakeLexerDATENAME = 212 + SnowflakeLexerDATEPART = 213 + SnowflakeLexerDATE_FORMAT = 214 + SnowflakeLexerDATE_INPUT_FORMAT = 215 + SnowflakeLexerDATE_OUTPUT_FORMAT = 216 + SnowflakeLexerDATE_PART = 217 + SnowflakeLexerDAYS = 218 + SnowflakeLexerDAYS_TO_EXPIRY = 219 + SnowflakeLexerDECLARE = 220 + SnowflakeLexerDEFAULT = 221 + SnowflakeLexerDEFAULT_DDL_COLLATION_ = 222 + SnowflakeLexerDEFAULT_NAMESPACE = 223 + SnowflakeLexerDEFAULT_ROLE = 224 + SnowflakeLexerDEFAULT_WAREHOUSE = 225 + SnowflakeLexerDEFERRABLE = 226 + SnowflakeLexerDEFERRED = 227 + SnowflakeLexerDEFINE = 228 + SnowflakeLexerDEFINITION = 229 + SnowflakeLexerDEFLATE = 230 + SnowflakeLexerDELEGATED = 231 + SnowflakeLexerDELETE = 232 + SnowflakeLexerDELTA = 233 + SnowflakeLexerDENSE_RANK = 234 + SnowflakeLexerDESC = 235 + SnowflakeLexerDESCRIBE = 236 + SnowflakeLexerDIRECTION = 237 + SnowflakeLexerDIRECTORY = 238 + SnowflakeLexerDISABLE = 239 + SnowflakeLexerDISABLED = 240 + SnowflakeLexerDISABLE_AUTO_CONVERT = 241 + SnowflakeLexerDISABLE_SNOWFLAKE_DATA = 242 + SnowflakeLexerDISK = 243 + SnowflakeLexerDISPLAY_NAME = 244 + SnowflakeLexerDISTINCT = 245 + SnowflakeLexerDO = 246 + SnowflakeLexerDOWNSTREAM = 247 + SnowflakeLexerDOUBLE = 248 + SnowflakeLexerDROP = 249 + SnowflakeLexerDYNAMIC = 250 + SnowflakeLexerECONOMY = 251 + SnowflakeLexerEDITION = 252 + SnowflakeLexerELSE = 253 + SnowflakeLexerEMAIL = 254 + SnowflakeLexerEMPTY_ = 255 + SnowflakeLexerEMPTY_FIELD_AS_NULL = 256 + SnowflakeLexerENABLE = 257 + SnowflakeLexerENABLED = 258 + SnowflakeLexerENABLE_FOR_PRIVILEGE = 259 + SnowflakeLexerENABLE_INTERNAL_STAGES_PRIVATELINK = 260 + SnowflakeLexerENABLE_OCTAL = 261 + SnowflakeLexerENABLE_QUERY_ACCELERATION = 262 + SnowflakeLexerENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION = 263 + SnowflakeLexerENCODING = 264 + SnowflakeLexerENCRYPTION = 265 + SnowflakeLexerEND = 266 + SnowflakeLexerENDPOINT = 267 + SnowflakeLexerEND_TIMESTAMP = 268 + SnowflakeLexerENFORCED = 269 + SnowflakeLexerENFORCE_LENGTH = 270 + SnowflakeLexerENFORCE_SESSION_POLICY = 271 + SnowflakeLexerENTERPRISE = 272 + SnowflakeLexerEQUALITY = 273 + SnowflakeLexerERROR_INTEGRATION = 274 + SnowflakeLexerERROR_ON_COLUMN_COUNT_MISMATCH = 275 + SnowflakeLexerERROR_ON_NONDETERMINISTIC_MERGE = 276 + SnowflakeLexerERROR_ON_NONDETERMINISTIC_UPDATE = 277 + SnowflakeLexerESCAPE = 278 + SnowflakeLexerESCAPE_UNENCLOSED_FIELD = 279 + SnowflakeLexerEXCEPT = 280 + SnowflakeLexerEXCHANGE = 281 + SnowflakeLexerEXECUTE = 282 + SnowflakeLexerEXECUTION = 283 + SnowflakeLexerEXIST = 284 + SnowflakeLexerEXISTS = 285 + SnowflakeLexerEXIT = 286 + SnowflakeLexerEXPAND = 287 + SnowflakeLexerEXPIRY_DATE = 288 + SnowflakeLexerEXPLAIN = 289 + SnowflakeLexerEXPLICIT = 290 + SnowflakeLexerEXTERNAL = 291 + SnowflakeLexerEXTERNAL_OAUTH = 292 + SnowflakeLexerEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST = 293 + SnowflakeLexerEXTERNAL_OAUTH_ALLOWED_ROLES_LIST = 294 + SnowflakeLexerEXTERNAL_OAUTH_ANY_ROLE_MODE = 295 + SnowflakeLexerEXTERNAL_OAUTH_AUDIENCE_LIST = 296 + SnowflakeLexerEXTERNAL_OAUTH_BLOCKED_ROLES_LIST = 297 + SnowflakeLexerEXTERNAL_OAUTH_ISSUER = 298 + SnowflakeLexerEXTERNAL_OAUTH_JWS_KEYS_URL = 299 + SnowflakeLexerEXTERNAL_OAUTH_RSA_PUBLIC_KEY = 300 + SnowflakeLexerEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2 = 301 + SnowflakeLexerEXTERNAL_OAUTH_SCOPE_DELIMITER = 302 + SnowflakeLexerEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE = 303 + SnowflakeLexerEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM = 304 + SnowflakeLexerEXTERNAL_OAUTH_TYPE = 305 + SnowflakeLexerEXTERNAL_STAGE = 306 + SnowflakeLexerFAILOVER = 307 + SnowflakeLexerFAILOVER_MODE = 308 + SnowflakeLexerFAIL_OPERATION = 309 + SnowflakeLexerFALSE = 310 + SnowflakeLexerFETCH = 311 + SnowflakeLexerFIELD_DELIMITER = 312 + SnowflakeLexerFIELD_OPTIONALLY_ENCLOSED_BY = 313 + SnowflakeLexerFILE = 314 + SnowflakeLexerFILES = 315 + SnowflakeLexerFILE_EXTENSION = 316 + SnowflakeLexerFILE_FORMAT = 317 + SnowflakeLexerFILTER = 318 + SnowflakeLexerFIRST = 319 + SnowflakeLexerFIRST_NAME = 320 + SnowflakeLexerFLATTEN = 321 + SnowflakeLexerFOR = 322 + SnowflakeLexerFORCE = 323 + SnowflakeLexerFOREIGN = 324 + SnowflakeLexerFORMAT = 325 + SnowflakeLexerFORMATS = 326 + SnowflakeLexerFORMAT_NAME = 327 + SnowflakeLexerFREQUENCY = 328 + SnowflakeLexerFROM = 329 + SnowflakeLexerFULL = 330 + SnowflakeLexerFUNCTION = 331 + SnowflakeLexerFUNCTIONS = 332 + SnowflakeLexerFUTURE = 333 + SnowflakeLexerGCP_PUBSUB = 334 + SnowflakeLexerGCP_PUBSUB_SUBSCRIPTION_NAME = 335 + SnowflakeLexerGCP_PUBSUB_TOPIC_NAME = 336 + SnowflakeLexerGCS = 337 + SnowflakeLexerGENERIC_Q = 338 + SnowflakeLexerGENERIC_SCIM_PROVISIONER_Q = 339 + SnowflakeLexerGEO = 340 + SnowflakeLexerGEOGRAPHY_OUTPUT_FORMAT = 341 + SnowflakeLexerGEOMETRY_OUTPUT_FORMAT = 342 + SnowflakeLexerGET = 343 + SnowflakeLexerGET_FILESTREAM_TRANSACTION_CONTEXT = 344 + SnowflakeLexerGLOBAL = 345 + SnowflakeLexerGOOGLE_AUDIENCE = 346 + SnowflakeLexerGOTO = 347 + SnowflakeLexerGRANT = 348 + SnowflakeLexerGRANTS = 349 + SnowflakeLexerGROUP = 350 + SnowflakeLexerGROUPING = 351 + SnowflakeLexerGROUPING_ID = 352 + SnowflakeLexerGROUPS = 353 + SnowflakeLexerGZIP = 354 + SnowflakeLexerHAVING = 355 + SnowflakeLexerHEADER = 356 + SnowflakeLexerHEADERS = 357 + SnowflakeLexerHEX = 358 + SnowflakeLexerHIERARCHYID = 359 + SnowflakeLexerHIGH = 360 + SnowflakeLexerHISTORY = 361 + SnowflakeLexerHOURS = 362 + SnowflakeLexerIDENTITY = 363 + SnowflakeLexerIF = 364 + SnowflakeLexerIFF = 365 + SnowflakeLexerIFNULL = 366 + SnowflakeLexerIGNORE = 367 + SnowflakeLexerIGNORE_CONSTRAINTS = 368 + SnowflakeLexerIGNORE_DUP_KEY = 369 + SnowflakeLexerIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX = 370 + SnowflakeLexerIGNORE_TRIGGERS = 371 + SnowflakeLexerIGNORE_UTF8_ERRORS = 372 + SnowflakeLexerILIKE = 373 + SnowflakeLexerIMMEDIATE = 374 + SnowflakeLexerIMMEDIATELY = 375 + SnowflakeLexerIMMUTABLE = 376 + SnowflakeLexerIMPLICIT = 377 + SnowflakeLexerIMPORT = 378 + SnowflakeLexerIMPORTED = 379 + SnowflakeLexerIN = 380 + SnowflakeLexerINCREMENT = 381 + SnowflakeLexerINDEX = 382 + SnowflakeLexerINFORMATION = 383 + SnowflakeLexerINIT = 384 + SnowflakeLexerINITIALLY = 385 + SnowflakeLexerINITIALLY_SUSPENDED = 386 + SnowflakeLexerINITIAL_REPLICATION_SIZE_LIMIT_IN_TB = 387 + SnowflakeLexerINNER = 388 + SnowflakeLexerINPUT = 389 + SnowflakeLexerINSERT = 390 + SnowflakeLexerINSERT_ONLY = 391 + SnowflakeLexerINSTEAD = 392 + SnowflakeLexerINT = 393 + SnowflakeLexerINTEGRATION = 394 + SnowflakeLexerINTEGRATIONS = 395 + SnowflakeLexerINTERSECT = 396 + SnowflakeLexerINTO = 397 + SnowflakeLexerIS = 398 + SnowflakeLexerISNULL = 399 + SnowflakeLexerISNUMERIC = 400 + SnowflakeLexerISOLATION = 401 + SnowflakeLexerJAVASCRIPT = 402 + SnowflakeLexerJDBC_TREAT_DECIMAL_AS_INT = 403 + SnowflakeLexerJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC = 404 + SnowflakeLexerJDBC_USE_SESSION_TIMEZONE = 405 + SnowflakeLexerJOIN = 406 + SnowflakeLexerJSON = 407 + SnowflakeLexerJSON_Q = 408 + SnowflakeLexerJSON_INDENT = 409 + SnowflakeLexerJS_TREAT_INTEGER_AS_BIGINT = 410 + SnowflakeLexerKB = 411 + SnowflakeLexerKEEP = 412 + SnowflakeLexerKEY = 413 + SnowflakeLexerKEYS = 414 + SnowflakeLexerKEYSET = 415 + SnowflakeLexerKMS_KEY_ID = 416 + SnowflakeLexerLAG = 417 + SnowflakeLexerLANGUAGE = 418 + SnowflakeLexerLARGE = 419 + SnowflakeLexerLAST = 420 + SnowflakeLexerLAST_NAME = 421 + SnowflakeLexerLAST_QUERY_ID = 422 + SnowflakeLexerLAST_VALUE = 423 + SnowflakeLexerLATERAL = 424 + SnowflakeLexerLEAD = 425 + SnowflakeLexerLEFT = 426 + SnowflakeLexerLEN = 427 + SnowflakeLexerLENGTH = 428 + SnowflakeLexerLEVEL = 429 + SnowflakeLexerLIKE = 430 + SnowflakeLexerLIMIT = 431 + SnowflakeLexerLINENO = 432 + SnowflakeLexerLIST = 433 + SnowflakeLexerLISTENER_IP = 434 + SnowflakeLexerLISTENER_PORT = 435 + SnowflakeLexerLISTING = 436 + SnowflakeLexerLOAD = 437 + SnowflakeLexerLOCAL = 438 + SnowflakeLexerLOCAL_SERVICE_NAME = 439 + SnowflakeLexerLOCATION = 440 + SnowflakeLexerLOCKS = 441 + SnowflakeLexerLOCK_TIMEOUT = 442 + SnowflakeLexerLOG = 443 + SnowflakeLexerLOGIN = 444 + SnowflakeLexerLOGIN_NAME = 445 + SnowflakeLexerLOOKER = 446 + SnowflakeLexerLOW = 447 + SnowflakeLexerLOWER = 448 + SnowflakeLexerLTRIM = 449 + SnowflakeLexerLZO = 450 + SnowflakeLexerMANAGE = 451 + SnowflakeLexerMANAGED = 452 + SnowflakeLexerMASK = 453 + SnowflakeLexerMASKED = 454 + SnowflakeLexerMASKING = 455 + SnowflakeLexerMASTER = 456 + SnowflakeLexerMASTER_KEY = 457 + SnowflakeLexerMATCH = 458 + SnowflakeLexerMATCHED = 459 + SnowflakeLexerMATCHES = 460 + SnowflakeLexerMATCH_BY_COLUMN_NAME = 461 + SnowflakeLexerMATCH_RECOGNIZE = 462 + SnowflakeLexerMATERIALIZED = 463 + SnowflakeLexerMAX_BATCH_ROWS = 464 + SnowflakeLexerMAX_CLUSTER_COUNT = 465 + SnowflakeLexerMAX_CONCURRENCY_LEVEL = 466 + SnowflakeLexerMAX_DATA_EXTENSION_TIME_IN_DAYS = 467 + SnowflakeLexerMAX_SIZE = 468 + SnowflakeLexerMEASURES = 469 + SnowflakeLexerMEDIUM = 470 + SnowflakeLexerMEMOIZABLE = 471 + SnowflakeLexerMERGE = 472 + SnowflakeLexerMIDDLE_NAME = 473 + SnowflakeLexerMIN = 474 + SnowflakeLexerMINS_TO_BYPASS_MFA = 475 + SnowflakeLexerMINS_TO_UNLOCK = 476 + SnowflakeLexerMINUS_ = 477 + SnowflakeLexerMINUTES = 478 + SnowflakeLexerMIN_CLUSTER_COUNT = 479 + SnowflakeLexerMIN_DATA_RETENTION_TIME_IN_DAYS = 480 + SnowflakeLexerMODE = 481 + SnowflakeLexerMODIFIED_AFTER = 482 + SnowflakeLexerMODIFY = 483 + SnowflakeLexerMONITOR = 484 + SnowflakeLexerMONITORS = 485 + SnowflakeLexerMONTHLY = 486 + SnowflakeLexerMOVE = 487 + SnowflakeLexerMULTI_STATEMENT_COUNT = 488 + SnowflakeLexerMULTI_USER = 489 + SnowflakeLexerMUST_CHANGE = 490 + SnowflakeLexerMUST_CHANGE_PASSWORD = 491 + SnowflakeLexerNAME = 492 + SnowflakeLexerNATURAL = 493 + SnowflakeLexerNCHAR = 494 + SnowflakeLexerNESTED_TRIGGERS = 495 + SnowflakeLexerNETWORK = 496 + SnowflakeLexerNETWORK_POLICY = 497 + SnowflakeLexerNEVER = 498 + SnowflakeLexerNEWID = 499 + SnowflakeLexerNEWNAME = 500 + SnowflakeLexerNEWSEQUENTIALID = 501 + SnowflakeLexerNEW_ACCOUNT = 502 + SnowflakeLexerNEW_BROKER = 503 + SnowflakeLexerNEW_PASSWORD = 504 + SnowflakeLexerNEXT = 505 + SnowflakeLexerNEXTVAL = 506 + SnowflakeLexerNO = 507 + SnowflakeLexerNONE = 508 + SnowflakeLexerNONE_Q = 509 + SnowflakeLexerNORELY = 510 + SnowflakeLexerNOT = 511 + SnowflakeLexerNOTIFICATION = 512 + SnowflakeLexerNOTIFICATIONS = 513 + SnowflakeLexerNOTIFICATION_INTEGRATION = 514 + SnowflakeLexerNOTIFICATION_PROVIDER = 515 + SnowflakeLexerNOTIFY = 516 + SnowflakeLexerNOTIFY_USERS = 517 + SnowflakeLexerNOVALIDATE = 518 + SnowflakeLexerNTILE = 519 + SnowflakeLexerNULLIF = 520 + SnowflakeLexerNULLS = 521 + SnowflakeLexerNULL_ = 522 + SnowflakeLexerNULL_IF = 523 + SnowflakeLexerNUMANODE = 524 + SnowflakeLexerNUMBER = 525 + SnowflakeLexerNUMERIC_ROUNDABORT = 526 + SnowflakeLexerNVL = 527 + SnowflakeLexerOAUTH = 528 + SnowflakeLexerOAUTH_ALLOW_NON_TLS_REDIRECT_URI = 529 + SnowflakeLexerOAUTH_CLIENT = 530 + SnowflakeLexerOAUTH_CLIENT_RSA_PUBLIC_KEY = 531 + SnowflakeLexerOAUTH_CLIENT_RSA_PUBLIC_KEY_2 = 532 + SnowflakeLexerOAUTH_ENFORCE_PKCE = 533 + SnowflakeLexerOAUTH_ISSUE_REFRESH_TOKENS = 534 + SnowflakeLexerOAUTH_REDIRECT_URI = 535 + SnowflakeLexerOAUTH_REFRESH_TOKEN_VALIDITY = 536 + SnowflakeLexerOAUTH_USE_SECONDARY_ROLES = 537 + SnowflakeLexerOBJECT = 538 + SnowflakeLexerOBJECT_Q = 539 + SnowflakeLexerOBJECTS = 540 + SnowflakeLexerOBJECT_TYPES = 541 + SnowflakeLexerOF = 542 + SnowflakeLexerOFF = 543 + SnowflakeLexerOFFSET = 544 + SnowflakeLexerOFFSETS = 545 + SnowflakeLexerOKTA = 546 + SnowflakeLexerOKTA_PROVISIONER_Q = 547 + SnowflakeLexerOKTA_Q = 548 + SnowflakeLexerOLD = 549 + SnowflakeLexerOLD_ACCOUNT = 550 + SnowflakeLexerOLD_PASSWORD = 551 + SnowflakeLexerOMIT = 552 + SnowflakeLexerON = 553 + SnowflakeLexerONE = 554 + SnowflakeLexerONLINE = 555 + SnowflakeLexerONLY = 556 + SnowflakeLexerON_ERROR = 557 + SnowflakeLexerON_FAILURE = 558 + SnowflakeLexerOPEN = 559 + SnowflakeLexerOPERATE = 560 + SnowflakeLexerOPERATIONS = 561 + SnowflakeLexerOPTIMIZATION = 562 + SnowflakeLexerOPTION = 563 + SnowflakeLexerOR = 564 + SnowflakeLexerORC = 565 + SnowflakeLexerORC_Q = 566 + SnowflakeLexerORDER = 567 + SnowflakeLexerORGADMIN = 568 + SnowflakeLexerORGANIZATION = 569 + SnowflakeLexerOUTBOUND = 570 + SnowflakeLexerOUTER = 571 + SnowflakeLexerOVER = 572 + SnowflakeLexerOVERRIDE = 573 + SnowflakeLexerOVERWRITE = 574 + SnowflakeLexerOWNER = 575 + SnowflakeLexerOWNERSHIP = 576 + SnowflakeLexerPAGE = 577 + SnowflakeLexerPARALLEL = 578 + SnowflakeLexerPARAMETERS = 579 + SnowflakeLexerPARAM_NODE = 580 + SnowflakeLexerPARQUET = 581 + SnowflakeLexerPARQUET_Q = 582 + SnowflakeLexerPARTIAL = 583 + SnowflakeLexerPARTITION = 584 + SnowflakeLexerPARTITIONS = 585 + SnowflakeLexerPARTITION_TYPE = 586 + SnowflakeLexerPASSWORD = 587 + SnowflakeLexerPAST = 588 + SnowflakeLexerPATH_ = 589 + SnowflakeLexerPATTERN = 590 + SnowflakeLexerPER = 591 + SnowflakeLexerPERCENT = 592 + SnowflakeLexerPERCENTILE_CONT = 593 + SnowflakeLexerPERCENTILE_DISC = 594 + SnowflakeLexerPERCENT_RANK = 595 + SnowflakeLexerPERIODIC_DATA_REKEYING = 596 + SnowflakeLexerPERMISSION_SET = 597 + SnowflakeLexerPERSISTED = 598 + SnowflakeLexerPERSIST_SAMPLE_PERCENT = 599 + SnowflakeLexerPING_FEDERATE = 600 + SnowflakeLexerPIPE = 601 + SnowflakeLexerPIPES = 602 + SnowflakeLexerPIPE_EXECUTION_PAUSED = 603 + SnowflakeLexerPIVOT = 604 + SnowflakeLexerPLAN = 605 + SnowflakeLexerPLATFORM = 606 + SnowflakeLexerPOLICIES = 607 + SnowflakeLexerPOLICY = 608 + SnowflakeLexerPOOL = 609 + SnowflakeLexerPORT = 610 + SnowflakeLexerPRECEDING = 611 + SnowflakeLexerPRECISION = 612 + SnowflakeLexerPREDICATE = 613 + SnowflakeLexerPREFIX = 614 + SnowflakeLexerPRESERVE_SPACE = 615 + SnowflakeLexerPREVENT_UNLOAD_TO_INLINE_URL = 616 + SnowflakeLexerPREVENT_UNLOAD_TO_INTERNAL_STAGES = 617 + SnowflakeLexerPRE_AUTHORIZED_ROLES_LIST = 618 + SnowflakeLexerPRIMARY = 619 + SnowflakeLexerPRIMARY_ROLE = 620 + SnowflakeLexerPRIOR = 621 + SnowflakeLexerPRIORITY = 622 + SnowflakeLexerPRIORITY_LEVEL = 623 + SnowflakeLexerPRIVATE = 624 + SnowflakeLexerPRIVATE_KEY = 625 + SnowflakeLexerPRIVILEGES = 626 + SnowflakeLexerPROC = 627 + SnowflakeLexerPROCEDURE = 628 + SnowflakeLexerPROCEDURES = 629 + SnowflakeLexerPROCEDURE_NAME = 630 + SnowflakeLexerPROCESS = 631 + SnowflakeLexerPROFILE = 632 + SnowflakeLexerPROPERTY = 633 + SnowflakeLexerPROVIDER = 634 + SnowflakeLexerPROVIDER_KEY_NAME = 635 + SnowflakeLexerPUBLIC = 636 + SnowflakeLexerPURGE = 637 + SnowflakeLexerPUT = 638 + SnowflakeLexerPYTHON = 639 + SnowflakeLexerQUALIFY = 640 + SnowflakeLexerQUERIES = 641 + SnowflakeLexerQUERY = 642 + SnowflakeLexerQUERY_ACCELERATION_MAX_SCALE_FACTOR = 643 + SnowflakeLexerQUERY_TAG = 644 + SnowflakeLexerQUEUE = 645 + SnowflakeLexerQUOTED_IDENTIFIERS_IGNORE_CASE = 646 + SnowflakeLexerRANGE = 647 + SnowflakeLexerRANK = 648 + SnowflakeLexerRAW_DEFLATE = 649 + SnowflakeLexerREAD = 650 + SnowflakeLexerREADER = 651 + SnowflakeLexerREADONLY = 652 + SnowflakeLexerREADPAST = 653 + SnowflakeLexerREADTEXT = 654 + SnowflakeLexerREADWRITE = 655 + SnowflakeLexerREAD_COMMITTED_SNAPSHOT = 656 + SnowflakeLexerREAD_ONLY = 657 + SnowflakeLexerREAD_ONLY_ROUTING_LIST = 658 + SnowflakeLexerREAD_WRITE = 659 + SnowflakeLexerREBUILD = 660 + SnowflakeLexerRECEIVE = 661 + SnowflakeLexerRECLUSTER = 662 + SnowflakeLexerRECOMPILE = 663 + SnowflakeLexerRECONFIGURE = 664 + SnowflakeLexerRECORD_DELIMITER = 665 + SnowflakeLexerRECOVERY = 666 + SnowflakeLexerRECURSIVE = 667 + SnowflakeLexerRECURSIVE_TRIGGERS = 668 + SnowflakeLexerREFERENCES = 669 + SnowflakeLexerREFERENCE_USAGE = 670 + SnowflakeLexerREFRESH = 671 + SnowflakeLexerREFRESH_ON_CREATE = 672 + SnowflakeLexerREGION = 673 + SnowflakeLexerREGIONS = 674 + SnowflakeLexerREGION_GROUP = 675 + SnowflakeLexerRELATIVE = 676 + SnowflakeLexerRELY = 677 + SnowflakeLexerREMOTE = 678 + SnowflakeLexerREMOTE_PROC_TRANSACTIONS = 679 + SnowflakeLexerREMOTE_SERVICE_NAME = 680 + SnowflakeLexerREMOVE = 681 + SnowflakeLexerRENAME = 682 + SnowflakeLexerREPEATABLE = 683 + SnowflakeLexerREPLACE = 684 + SnowflakeLexerREPLACE_INVALID_CHARACTERS = 685 + SnowflakeLexerREPLICA = 686 + SnowflakeLexerREPLICATION = 687 + SnowflakeLexerREPLICATION_SCHEDULE = 688 + SnowflakeLexerREQUEST_TRANSLATOR = 689 + SnowflakeLexerREQUIRED = 690 + SnowflakeLexerREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION = 691 + SnowflakeLexerREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION = 692 + SnowflakeLexerRESET = 693 + SnowflakeLexerRESOURCE = 694 + SnowflakeLexerRESOURCES = 695 + SnowflakeLexerRESOURCE_MONITOR = 696 + SnowflakeLexerRESPONSE_TRANSLATOR = 697 + SnowflakeLexerRESTART = 698 + SnowflakeLexerRESTORE = 699 + SnowflakeLexerRESTRICT = 700 + SnowflakeLexerRESTRICTIONS = 701 + SnowflakeLexerRESULT = 702 + SnowflakeLexerRESUME = 703 + SnowflakeLexerRETAINDAYS = 704 + SnowflakeLexerRETURN = 705 + SnowflakeLexerRETURNS = 706 + SnowflakeLexerRETURN_ALL_ERRORS = 707 + SnowflakeLexerRETURN_ERRORS = 708 + SnowflakeLexerRETURN_FAILED_ONLY = 709 + SnowflakeLexerRETURN_N_ROWS = 710 + SnowflakeLexerRETURN_ROWS = 711 + SnowflakeLexerREVERSE = 712 + SnowflakeLexerREVERT = 713 + SnowflakeLexerREVOKE = 714 + SnowflakeLexerREWIND = 715 + SnowflakeLexerRIGHT = 716 + SnowflakeLexerRLIKE = 717 + SnowflakeLexerROLE = 718 + SnowflakeLexerROLES = 719 + SnowflakeLexerROLLBACK = 720 + SnowflakeLexerROLLUP = 721 + SnowflakeLexerROOT = 722 + SnowflakeLexerROW = 723 + SnowflakeLexerROWCOUNT = 724 + SnowflakeLexerROWGUID = 725 + SnowflakeLexerROWLOCK = 726 + SnowflakeLexerROWS = 727 + SnowflakeLexerROWS_PER_RESULTSET = 728 + SnowflakeLexerROW_NUMBER = 729 + SnowflakeLexerRSA_PUBLIC_KEY = 730 + SnowflakeLexerRSA_PUBLIC_KEY_2 = 731 + SnowflakeLexerRTRIM = 732 + SnowflakeLexerRUN_AS_ROLE = 733 + SnowflakeLexerS3 = 734 + SnowflakeLexerSAFE = 735 + SnowflakeLexerSAFETY = 736 + SnowflakeLexerSAML2 = 737 + SnowflakeLexerSAML2_ENABLE_SP_INITIATED = 738 + SnowflakeLexerSAML2_FORCE_AUTHN = 739 + SnowflakeLexerSAML2_ISSUER = 740 + SnowflakeLexerSAML2_POST_LOGOUT_REDIRECT_URL = 741 + SnowflakeLexerSAML2_PROVIDER = 742 + SnowflakeLexerSAML2_REQUESTED_NAMEID_FORMAT = 743 + SnowflakeLexerSAML2_SIGN_REQUEST = 744 + SnowflakeLexerSAML2_SNOWFLAKE_ACS_URL = 745 + SnowflakeLexerSAML2_SNOWFLAKE_ISSUER_URL = 746 + SnowflakeLexerSAML2_SNOWFLAKE_X509_CERT = 747 + SnowflakeLexerSAML2_SP_INITIATED_LOGIN_PAGE_LABEL = 748 + SnowflakeLexerSAML2_SSO_URL = 749 + SnowflakeLexerSAML2_X509_CERT = 750 + SnowflakeLexerSAML_IDENTITY_PROVIDER = 751 + SnowflakeLexerSAMPLE = 752 + SnowflakeLexerSAVE_OLD_URL = 753 + SnowflakeLexerSCALING_POLICY = 754 + SnowflakeLexerSCHEDULE = 755 + SnowflakeLexerSCHEDULER = 756 + SnowflakeLexerSCHEMA = 757 + SnowflakeLexerSCHEMAS = 758 + SnowflakeLexerSCHEME = 759 + SnowflakeLexerSCIM = 760 + SnowflakeLexerSCIM_CLIENT = 761 + SnowflakeLexerSCRIPT = 762 + SnowflakeLexerSEARCH = 763 + SnowflakeLexerSECONDARY = 764 + SnowflakeLexerSECONDARY_ONLY = 765 + SnowflakeLexerSECONDARY_ROLE = 766 + SnowflakeLexerSECONDS = 767 + SnowflakeLexerSECRET = 768 + SnowflakeLexerSECURE = 769 + SnowflakeLexerSECURITY = 770 + SnowflakeLexerSECURITYADMIN = 771 + SnowflakeLexerSEED = 772 + SnowflakeLexerSELECT = 773 + SnowflakeLexerSELF = 774 + SnowflakeLexerSEQUENCE = 775 + SnowflakeLexerSEQUENCES = 776 + SnowflakeLexerSERVER = 777 + SnowflakeLexerSERVICE = 778 + SnowflakeLexerSESSION = 779 + SnowflakeLexerSESSION_IDLE_TIMEOUT_MINS = 780 + SnowflakeLexerSESSION_POLICY = 781 + SnowflakeLexerSESSION_UI_IDLE_TIMEOUT_MINS = 782 + SnowflakeLexerSET = 783 + SnowflakeLexerSETS = 784 + SnowflakeLexerSETUSER = 785 + SnowflakeLexerSHARE = 786 + SnowflakeLexerSHARED = 787 + SnowflakeLexerSHARES = 788 + SnowflakeLexerSHARE_RESTRICTIONS = 789 + SnowflakeLexerSHOW = 790 + SnowflakeLexerSHOWPLAN = 791 + SnowflakeLexerSHOWPLAN_ALL = 792 + SnowflakeLexerSHOWPLAN_TEXT = 793 + SnowflakeLexerSHOWPLAN_XML = 794 + SnowflakeLexerSHOW_INITIAL_ROWS = 795 + SnowflakeLexerSIGNATURE = 796 + SnowflakeLexerSIMPLE = 797 + SnowflakeLexerSIMULATED_DATA_SHARING_CONSUMER = 798 + SnowflakeLexerSINGLE_USER = 799 + SnowflakeLexerSIZE = 800 + SnowflakeLexerSIZE_LIMIT = 801 + SnowflakeLexerSKIP_ = 802 + SnowflakeLexerSKIP_BLANK_LINES = 803 + SnowflakeLexerSKIP_BYTE_ORDER_MARK = 804 + SnowflakeLexerSKIP_FILE = 805 + SnowflakeLexerSKIP_FILE_N = 806 + SnowflakeLexerSKIP_HEADER = 807 + SnowflakeLexerSMALL = 808 + SnowflakeLexerSNAPPY = 809 + SnowflakeLexerSNAPPY_COMPRESSION = 810 + SnowflakeLexerSOME = 811 + SnowflakeLexerSOUNDEX = 812 + SnowflakeLexerSOURCE = 813 + SnowflakeLexerSOURCE_COMPRESSION = 814 + SnowflakeLexerSPACE_KEYWORD = 815 + SnowflakeLexerSPARSE = 816 + SnowflakeLexerSPECIFICATION = 817 + SnowflakeLexerSPLIT = 818 + SnowflakeLexerSPLIT_PART = 819 + SnowflakeLexerSQL = 820 + SnowflakeLexerSSO_LOGIN_PAGE = 821 + SnowflakeLexerSTAGE = 822 + SnowflakeLexerSTAGES = 823 + SnowflakeLexerSTAGE_COPY_OPTIONS = 824 + SnowflakeLexerSTAGE_FILE_FORMAT = 825 + SnowflakeLexerSTANDARD = 826 + SnowflakeLexerSTANDBY = 827 + SnowflakeLexerSTART = 828 + SnowflakeLexerSTARTED = 829 + SnowflakeLexerSTARTS = 830 + SnowflakeLexerSTART_DATE = 831 + SnowflakeLexerSTART_TIMESTAMP = 832 + SnowflakeLexerSTATE = 833 + SnowflakeLexerSTATEMENT = 834 + SnowflakeLexerSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS = 835 + SnowflakeLexerSTATEMENT_TIMEOUT_IN_SECONDS = 836 + SnowflakeLexerSTATIC = 837 + SnowflakeLexerSTATISTICS = 838 + SnowflakeLexerSTATS = 839 + SnowflakeLexerSTATS_DATE = 840 + SnowflakeLexerSTATS_STREAM = 841 + SnowflakeLexerSTATUS = 842 + SnowflakeLexerSTATUSONLY = 843 + SnowflakeLexerSTDEV = 844 + SnowflakeLexerSTDEVP = 845 + SnowflakeLexerSTOP = 846 + SnowflakeLexerSTOPLIST = 847 + SnowflakeLexerSTOPPED = 848 + SnowflakeLexerSTORAGE = 849 + SnowflakeLexerSTORAGE_ALLOWED_LOCATIONS = 850 + SnowflakeLexerSTORAGE_AWS_OBJECT_ACL = 851 + SnowflakeLexerSTORAGE_AWS_ROLE_ARN = 852 + SnowflakeLexerSTORAGE_BLOCKED_LOCATIONS = 853 + SnowflakeLexerSTORAGE_INTEGRATION = 854 + SnowflakeLexerSTORAGE_PROVIDER = 855 + SnowflakeLexerSTR = 856 + SnowflakeLexerSTREAM = 857 + SnowflakeLexerSTREAMS = 858 + SnowflakeLexerSTRICT = 859 + SnowflakeLexerSTRICT_JSON_OUTPUT = 860 + SnowflakeLexerSTRING_AGG = 861 + SnowflakeLexerSTRING_ESCAPE = 862 + SnowflakeLexerSTRIP_NULL_VALUES = 863 + SnowflakeLexerSTRIP_OUTER_ARRAY = 864 + SnowflakeLexerSTRIP_OUTER_ELEMENT = 865 + SnowflakeLexerSUBSTR = 866 + SnowflakeLexerSUBSTRING = 867 + SnowflakeLexerSUM = 868 + SnowflakeLexerSUPPORTED = 869 + SnowflakeLexerSUSPEND = 870 + SnowflakeLexerSUSPENDED = 871 + SnowflakeLexerSUSPEND_IMMEDIATE = 872 + SnowflakeLexerSUSPEND_TASK_AFTER_NUM_FAILURES = 873 + SnowflakeLexerSWAP = 874 + SnowflakeLexerSWITCH = 875 + SnowflakeLexerSYNC_PASSWORD = 876 + SnowflakeLexerSYSADMIN = 877 + SnowflakeLexerSYSTEM = 878 + SnowflakeLexerSYSTEM_USER = 879 + SnowflakeLexerTABLE = 880 + SnowflakeLexerTABLEAU_DESKTOP = 881 + SnowflakeLexerTABLEAU_SERVER = 882 + SnowflakeLexerTABLES = 883 + SnowflakeLexerTABLESAMPLE = 884 + SnowflakeLexerTABLE_FORMAT = 885 + SnowflakeLexerTABULAR = 886 + SnowflakeLexerTAG = 887 + SnowflakeLexerTAGS = 888 + SnowflakeLexerTARGET = 889 + SnowflakeLexerTARGET_LAG = 890 + SnowflakeLexerTASK = 891 + SnowflakeLexerTASKS = 892 + SnowflakeLexerTEMP = 893 + SnowflakeLexerTEMPORARY = 894 + SnowflakeLexerTERSE = 895 + SnowflakeLexerTEXTSIZE = 896 + SnowflakeLexerTHEN = 897 + SnowflakeLexerTIES = 898 + SnowflakeLexerTIME = 899 + SnowflakeLexerTIMEADD = 900 + SnowflakeLexerTIMEDIFF = 901 + SnowflakeLexerTIMEOUT = 902 + SnowflakeLexerTIMER = 903 + SnowflakeLexerTIMESTAMP = 904 + SnowflakeLexerTIMESTAMP_DAY_IS_ALWAYS_24H = 905 + SnowflakeLexerTIMESTAMP_FORMAT = 906 + SnowflakeLexerTIMESTAMP_INPUT_FORMAT = 907 + SnowflakeLexerTIMESTAMP_LTZ = 908 + SnowflakeLexerTIMESTAMP_LTZ_OUTPUT_FORMAT = 909 + SnowflakeLexerTIMESTAMP_NTZ = 910 + SnowflakeLexerTIMESTAMP_NTZ_OUTPUT_FORMAT = 911 + SnowflakeLexerTIMESTAMP_OUTPUT_FORMAT = 912 + SnowflakeLexerTIMESTAMP_TYPE_MAPPING = 913 + SnowflakeLexerTIMESTAMP_TZ = 914 + SnowflakeLexerTIMESTAMP_TZ_OUTPUT_FORMAT = 915 + SnowflakeLexerTIMESTAMPADD = 916 + SnowflakeLexerTIMESTAMPDIFF = 917 + SnowflakeLexerTIMEZONE = 918 + SnowflakeLexerTIME_FORMAT = 919 + SnowflakeLexerTIME_INPUT_FORMAT = 920 + SnowflakeLexerTIME_OUTPUT_FORMAT = 921 + SnowflakeLexerTO = 922 + SnowflakeLexerTO_BOOLEAN = 923 + SnowflakeLexerTO_DATE = 924 + SnowflakeLexerTOP = 925 + SnowflakeLexerTORN_PAGE_DETECTION = 926 + SnowflakeLexerTRACKING = 927 + SnowflakeLexerTRACK_CAUSALITY = 928 + SnowflakeLexerTRAN = 929 + SnowflakeLexerTRANSACTION = 930 + SnowflakeLexerTRANSACTIONS = 931 + SnowflakeLexerTRANSACTION_ABORT_ON_ERROR = 932 + SnowflakeLexerTRANSACTION_DEFAULT_ISOLATION_LEVEL = 933 + SnowflakeLexerTRANSACTION_ID = 934 + SnowflakeLexerTRANSFORM_NOISE_WORDS = 935 + SnowflakeLexerTRANSIENT = 936 + SnowflakeLexerTRANSLATE = 937 + SnowflakeLexerTRIGGER = 938 + SnowflakeLexerTRIGGERS = 939 + SnowflakeLexerTRIM = 940 + SnowflakeLexerTRIM_SPACE = 941 + SnowflakeLexerTRIPLE_DES = 942 + SnowflakeLexerTRIPLE_DES_3KEY = 943 + SnowflakeLexerTRUE = 944 + SnowflakeLexerTRUNCATE = 945 + SnowflakeLexerTRUNCATECOLUMNS = 946 + SnowflakeLexerTRUSTWORTHY = 947 + SnowflakeLexerTRY = 948 + SnowflakeLexerTRY_CAST = 949 + SnowflakeLexerTSEQUAL = 950 + SnowflakeLexerTSQL = 951 + SnowflakeLexerTWO_DIGIT_CENTURY_START = 952 + SnowflakeLexerTWO_DIGIT_YEAR_CUTOFF = 953 + SnowflakeLexerTYPE = 954 + SnowflakeLexerTYPEPROPERTY = 955 + SnowflakeLexerTYPE_ID = 956 + SnowflakeLexerTYPE_NAME = 957 + SnowflakeLexerTYPE_WARNING = 958 + SnowflakeLexerUN = 959 + SnowflakeLexerUNBOUNDED = 960 + SnowflakeLexerUNCHECKED = 961 + SnowflakeLexerUNCOMMITTED = 962 + SnowflakeLexerUNDROP = 963 + SnowflakeLexerUNICODE = 964 + SnowflakeLexerUNION = 965 + SnowflakeLexerUNIQUE = 966 + SnowflakeLexerUNKNOWN = 967 + SnowflakeLexerUNLIMITED = 968 + SnowflakeLexerUNLOCK = 969 + SnowflakeLexerUNMASK = 970 + SnowflakeLexerUNMATCHED = 971 + SnowflakeLexerUNPIVOT = 972 + SnowflakeLexerUNSAFE = 973 + SnowflakeLexerUNSET = 974 + SnowflakeLexerUNSUPPORTED_DDL_ACTION = 975 + SnowflakeLexerUOW = 976 + SnowflakeLexerUPDATE = 977 + SnowflakeLexerUPDLOCK = 978 + SnowflakeLexerUPPER = 979 + SnowflakeLexerURL = 980 + SnowflakeLexerUSAGE = 981 + SnowflakeLexerUSE = 982 + SnowflakeLexerUSED = 983 + SnowflakeLexerUSER = 984 + SnowflakeLexerUSERADMIN = 985 + SnowflakeLexerUSERS = 986 + SnowflakeLexerUSER_SPECIFIED = 987 + SnowflakeLexerUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE = 988 + SnowflakeLexerUSER_TASK_TIMEOUT_MS = 989 + SnowflakeLexerUSE_ANY_ROLE = 990 + SnowflakeLexerUSE_CACHED_RESULT = 991 + SnowflakeLexerUSING = 992 + SnowflakeLexerUTF8 = 993 + SnowflakeLexerVALIDATE = 994 + SnowflakeLexerVALIDATION = 995 + SnowflakeLexerVALIDATION_MODE = 996 + SnowflakeLexerVALID_XML = 997 + SnowflakeLexerVALUE = 998 + SnowflakeLexerVALUES = 999 + SnowflakeLexerVAR = 1000 + SnowflakeLexerVARIABLES = 1001 + SnowflakeLexerVARP = 1002 + SnowflakeLexerVARYING = 1003 + SnowflakeLexerVERSION = 1004 + SnowflakeLexerVIEW = 1005 + SnowflakeLexerVIEWS = 1006 + SnowflakeLexerVIEW_METADATA = 1007 + SnowflakeLexerVISIBILITY = 1008 + SnowflakeLexerVOLATILE = 1009 + SnowflakeLexerWAIT = 1010 + SnowflakeLexerWAREHOUSE = 1011 + SnowflakeLexerWAREHOUSES = 1012 + SnowflakeLexerWAREHOUSE_SIZE = 1013 + SnowflakeLexerWEEKLY = 1014 + SnowflakeLexerWEEK_OF_YEAR_POLICY = 1015 + SnowflakeLexerWEEK_START = 1016 + SnowflakeLexerWELL_FORMED_XML = 1017 + SnowflakeLexerWHEN = 1018 + SnowflakeLexerWHERE = 1019 + SnowflakeLexerWITH = 1020 + SnowflakeLexerWITHIN = 1021 + SnowflakeLexerWITHOUT = 1022 + SnowflakeLexerWITHOUT_ARRAY_WRAPPER = 1023 + SnowflakeLexerWORK = 1024 + SnowflakeLexerWORKLOAD = 1025 + SnowflakeLexerWRITE = 1026 + SnowflakeLexerX4LARGE = 1027 + SnowflakeLexerX5LARGE = 1028 + SnowflakeLexerX6LARGE = 1029 + SnowflakeLexerXLARGE = 1030 + SnowflakeLexerXLOCK = 1031 + SnowflakeLexerXML = 1032 + SnowflakeLexerXML_Q = 1033 + SnowflakeLexerXSMALL = 1034 + SnowflakeLexerXXLARGE = 1035 + SnowflakeLexerXXXLARGE = 1036 + SnowflakeLexerYEARLY = 1037 + SnowflakeLexerZSTD = 1038 + SnowflakeLexerARRAY = 1039 + SnowflakeLexerARRAY_Q = 1040 + SnowflakeLexerBIGINT = 1041 + SnowflakeLexerBINARY = 1042 + SnowflakeLexerBOOLEAN = 1043 + SnowflakeLexerBYTEINT = 1044 + SnowflakeLexerCHAR_VARYING = 1045 + SnowflakeLexerDATE = 1046 + SnowflakeLexerDATETIME = 1047 + SnowflakeLexerDECIMAL_ = 1048 + SnowflakeLexerFLOAT4 = 1049 + SnowflakeLexerFLOAT8 = 1050 + SnowflakeLexerFLOAT_ = 1051 + SnowflakeLexerGEOGRAPHY = 1052 + SnowflakeLexerGEOMETRY = 1053 + SnowflakeLexerINTEGER = 1054 + SnowflakeLexerNCHAR_VARYING = 1055 + SnowflakeLexerNUMERIC = 1056 + SnowflakeLexerNVARCHAR2 = 1057 + SnowflakeLexerNVARCHAR = 1058 + SnowflakeLexerREAL_ = 1059 + SnowflakeLexerSMALLINT = 1060 + SnowflakeLexerSTRING_ = 1061 + SnowflakeLexerTEXT = 1062 + SnowflakeLexerTINYINT = 1063 + SnowflakeLexerVARBINARY = 1064 + SnowflakeLexerVARCHAR = 1065 + SnowflakeLexerVARIANT = 1066 + SnowflakeLexerLISTAGG = 1067 + SnowflakeLexerDUMMY = 1068 + SnowflakeLexerSPACE = 1069 + SnowflakeLexerSQL_COMMENT = 1070 + SnowflakeLexerLINE_COMMENT = 1071 + SnowflakeLexerLINE_COMMENT_2 = 1072 + SnowflakeLexerDOUBLE_QUOTE_ID = 1073 + SnowflakeLexerDOUBLE_QUOTE_BLANK = 1074 + SnowflakeLexerSINGLE_QUOTE = 1075 + SnowflakeLexerID = 1076 + SnowflakeLexerID2 = 1077 + SnowflakeLexerS3_PATH = 1078 + SnowflakeLexerGCS_PATH = 1079 + SnowflakeLexerAZURE_PATH = 1080 + SnowflakeLexerFILE_PATH = 1081 + SnowflakeLexerDBL_DOLLAR = 1082 + SnowflakeLexerSTRING = 1083 + SnowflakeLexerDECIMAL = 1084 + SnowflakeLexerFLOAT = 1085 + SnowflakeLexerREAL = 1086 + SnowflakeLexerCHAR_LITERAL = 1087 + SnowflakeLexerARROW = 1088 + SnowflakeLexerASSOC = 1089 + SnowflakeLexerNE = 1090 + SnowflakeLexerLTGT = 1091 + SnowflakeLexerEQ = 1092 + SnowflakeLexerGT = 1093 + SnowflakeLexerGE = 1094 + SnowflakeLexerLT = 1095 + SnowflakeLexerLE = 1096 + SnowflakeLexerEXCLAMATION = 1097 + SnowflakeLexerPIPE_PIPE = 1098 + SnowflakeLexerDOT = 1099 + SnowflakeLexerUNDERLINE = 1100 + SnowflakeLexerAT = 1101 + SnowflakeLexerAT_Q = 1102 + SnowflakeLexerDOLLAR = 1103 + SnowflakeLexerLR_BRACKET = 1104 + SnowflakeLexerRR_BRACKET = 1105 + SnowflakeLexerLSB = 1106 + SnowflakeLexerRSB = 1107 + SnowflakeLexerLCB = 1108 + SnowflakeLexerRCB = 1109 + SnowflakeLexerCOMMA = 1110 + SnowflakeLexerSEMI = 1111 + SnowflakeLexerCOLON = 1112 + SnowflakeLexerCOLON_COLON = 1113 + SnowflakeLexerSTAR = 1114 + SnowflakeLexerDIVIDE = 1115 + SnowflakeLexerMODULE = 1116 + SnowflakeLexerPLUS = 1117 + SnowflakeLexerMINUS = 1118 + SnowflakeLexerPLACEHOLDER = 1119 +) diff --git a/snowflake/snowflake_parser.go b/snowflake/snowflake_parser.go new file mode 100644 index 0000000..61060e3 --- /dev/null +++ b/snowflake/snowflake_parser.go @@ -0,0 +1,177870 @@ +// Code generated from SnowflakeParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package snowflake // SnowflakeParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type SnowflakeParser struct { + *antlr.BaseParser +} + +var SnowflakeParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func snowflakeparserParserInit() { + staticData := &SnowflakeParserParserStaticData + staticData.LiteralNames = []string{ + "", "''AAD_PROVISIONER''", "'ABORT'", "'ABORT_AFTER_WAIT'", "'ABORT_DETACHED_QUERY'", + "'ABORT_STATEMENT'", "'ABSENT'", "'ABSOLUTE'", "'ACCESS'", "'ACCOUNT'", + "'ACCOUNTADMIN'", "'ACCOUNTS'", "'ACTION'", "'ACTIVE'", "'ADD'", "'ADMINISTER'", + "'ADMIN_NAME'", "'ADMIN_PASSWORD'", "'AES'", "'AFTER'", "'AGGREGATE'", + "'ALERT'", "'ALERTS'", "'ALL'", "'ALLOWED'", "'ALLOWED_ACCOUNTS'", "'ALLOWED_DATABASES'", + "'ALLOWED_INTEGRATION_TYPES'", "'ALLOWED_IP_LIST'", "'ALLOWED_SHARES'", + "'ALLOWED_VALUES'", "'ALLOW_CLIENT_MFA_CACHING'", "'ALLOW_CONNECTIONS'", + "'ALLOW_DUPLICATE'", "'ALLOW_ID_TOKEN'", "'ALLOW_MULTIPLE_EVENT_LOSS'", + "'ALLOW_OVERLAPPING_EXECUTION'", "'ALLOW_SINGLE_EVENT_LOSS'", "'ALTER'", + "'ALWAYS'", "'AND'", "'ANONYMOUS'", "'ANSI_DEFAULTS'", "'ANY'", "'API'", + "'API_ALLOWED_PREFIXES'", "'API_AWS_ROLE_ARN'", "'API_BLOCKED_PREFIXES'", + "'API_INTEGRATION'", "'API_KEY'", "'API_PROVIDER'", "'APPEND'", "'APPEND_ONLY'", + "'APPLICATION'", "'APPLY'", "'APP_NAME'", "'AS'", "'ASC'", "'ATTACH'", + "'AT'", "'AUTHORIZATION'", "'AUTHORIZATIONS'", "'AUTO'", "''AUTO''", + "'AUTOCOMMIT'", "'AUTOCOMMIT_API_SUPPORTED'", "'AUTOINCREMENT'", "'AUTO_COMPRESS'", + "'AUTO_DETECT'", "'AUTO_INGEST'", "'AUTO_REFRESH'", "'AUTO_RESUME'", + "'AUTO_SUSPEND'", "'AVG'", "'AVRO'", "''AVRO''", "'AWS_KEY_ID'", "'AWS_ROLE'", + "'AWS_SECRET_KEY'", "'AWS_SNS'", "'AWS_SNS_ROLE_ARN'", "'AWS_SNS_TOPIC'", + "'AWS_SNS_TOPIC_ARN'", "'AWS_TOKEN'", "'AZURE'", "'AZURE_AD_APPLICATION_ID'", + "'AZURE_EVENT_GRID'", "'AZURE_EVENT_GRID_TOPIC_ENDPOINT'", "''AZURE''", + "'AZURE_SAS_TOKEN'", "'AZURE_STORAGE_QUEUE_PRIMARY_URI'", "'AZURE_TENANT_ID'", + "'BASE64'", "'BEFORE'", "'BEGIN'", "'BERNOULLI'", "'BETWEEN'", "'BINARY_AS_TEXT'", + "'BINARY_CHECKSUM'", "'BINARY_FORMAT'", "'BINARY_INPUT_FORMAT'", "'BINARY_OUTPUT_FORMAT'", + "'BINDING'", "'BLOCK'", "'BLOCKED_IP_LIST'", "'BLOCKED_ROLES_LIST'", + "'BODY'", "''BOTH''", "'BROTLI'", "'BUSINESS_CRITICAL'", "'BY'", "'BZ2'", + "'CACHE'", "'CALL'", "'CALLED'", "'CALLER'", "'CASCADE'", "'CASE'", + "'CASE_INSENSITIVE'", "'CASE_SENSITIVE'", "'CAST'", "'CATCH'", "'CERTIFICATE'", + "'CHANGE'", "'CHANGES'", "'CHANGETABLE'", "'CHANGE_RETENTION'", "'CHANGE_TRACKING'", + "'CHAR'", "'CHARACTER'", "'CHARINDEX'", "'CHECK'", "'CHECKSUM'", "'CHECKSUM_AGG'", + "'CHECK_EXPIRATION'", "'CHECK_POLICY'", "'CLASSIFIER_FUNCTION'", "'CLEANUP'", + "'CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS'", "'CLIENT_ENCRYPTION_KEY_SIZE'", + "'CLIENT_MEMORY_LIMIT'", "'CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX'", + "'CLIENT_METADATA_USE_SESSION_DATABASE'", "'CLIENT_PREFETCH_THREADS'", + "'CLIENT_RESULT_CHUNK_SIZE'", "'CLIENT_RESULT_COLUMN_CASE_INSENSITIVE'", + "'CLIENT_SESSION_KEEP_ALIVE'", "'CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY'", + "'CLIENT_TIMESTAMP_TYPE_MAPPING'", "'CLONE'", "'CLOSE'", "'CLUSTER'", + "'CLUSTERED'", "'CLUSTERING'", "'COALESCE'", "'COLLATE'", "'COLLECTION'", + "'COLUMN'", "'COLUMNS'", "'COL_LENGTH'", "'COL_NAME'", "'COMMENT'", + "'COMMIT'", "'COMMITTED'", "'COMPRESS'", "'COMPRESSION'", "'CONCAT'", + "'CONCAT_NULL_YIELDS_NULL'", "'CONCAT_WS'", "'CONDITION'", "'CONFIGURATION'", + "'CONNECT'", "'CONNECTION'", "'CONNECTIONS'", "'CONSTRAINT'", "'CONTAINMENT'", + "'CONTAINS'", "'CONTENT'", "'CONTEXT'", "'CONTEXT_HEADERS'", "'CONTEXT_INFO'", + "'CONTINUE'", "'CONTROL'", "'CONVERSATION'", "'COOKIE'", "'COPY'", "'COPY_ONLY'", + "'COPY_OPTIONS'", "'COUNT'", "'COUNT_BIG'", "'CREATE'", "'CREDENTIALS'", + "'CREDIT_QUOTA'", "'CROSS'", "'CSV'", "''CSV''", "'CUBE'", "'CUME_DIST'", + "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_USER'", "'CURSOR'", "'CUSTOM'", "'DAILY'", "'DATA'", "'DATABASE'", + "'DATABASES'", "'DATA_RETENTION_TIME_IN_DAYS'", "'DATEADD'", "'DATEDIFF'", + "'DATENAME'", "'DATEPART'", "'DATE_FORMAT'", "'DATE_INPUT_FORMAT'", + "'DATE_OUTPUT_FORMAT'", "'DATE_PART'", "'DAYS'", "'DAYS_TO_EXPIRY'", + "'DECLARE'", "'DEFAULT'", "'DEFAULT_DDL_COLLATION'", "'DEFAULT_NAMESPACE'", + "'DEFAULT_ROLE'", "'DEFAULT_WAREHOUSE'", "'DEFERRABLE'", "'DEFERRED'", + "'DEFINE'", "'DEFINITION'", "'DEFLATE'", "'DELEGATED'", "'DELETE'", + "'DELTA'", "'DENSE_RANK'", "'DESC'", "'DESCRIBE'", "'DIRECTION'", "'DIRECTORY'", + "'DISABLE'", "'DISABLED'", "'DISABLE_AUTO_CONVERT'", "'DISABLE_SNOWFLAKE_DATA'", + "'DISK'", "'DISPLAY_NAME'", "'DISTINCT'", "'DO'", "'DOWNSTREAM'", "'DOUBLE'", + "'DROP'", "'DYNAMIC'", "'ECONOMY'", "'EDITION'", "'ELSE'", "'EMAIL'", + "'EMPTY'", "'EMPTY_FIELD_AS_NULL'", "'ENABLE'", "'ENABLED'", "'ENABLE_FOR_PRIVILEGE'", + "'ENABLE_INTERNAL_STAGES_PRIVATELINK'", "'ENABLE_OCTAL'", "'ENABLE_QUERY_ACCELERATION'", + "'ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION'", "'ENCODING'", "'ENCRYPTION'", + "'END'", "'ENDPOINT'", "'END_TIMESTAMP'", "'ENFORCED'", "'ENFORCE_LENGTH'", + "'ENFORCE_SESSION_POLICY'", "'ENTERPRISE'", "'EQUALITY'", "'ERROR_INTEGRATION'", + "'ERROR_ON_COLUMN_COUNT_MISMATCH'", "'ERROR_ON_NONDETERMINISTIC_MERGE'", + "'ERROR_ON_NONDETERMINISTIC_UPDATE'", "'ESCAPE'", "'ESCAPE_UNENCLOSED_FIELD'", + "'EXCEPT'", "'EXCHANGE'", "", "'EXECUTION'", "'EXIST'", "'EXISTS'", + "'EXIT'", "'EXPAND'", "'EXPIRY_DATE'", "'EXPLAIN'", "'EXPLICIT'", "'EXTERNAL'", + "'EXTERNAL_OAUTH'", "'EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST'", + "'EXTERNAL_OAUTH_ALLOWED_ROLES_LIST'", "'EXTERNAL_OAUTH_ANY_ROLE_MODE'", + "'EXTERNAL_OAUTH_AUDIENCE_LIST'", "'EXTERNAL_OAUTH_BLOCKED_ROLES_LIST'", + "'EXTERNAL_OAUTH_ISSUER'", "'EXTERNAL_OAUTH_JWS_KEYS_URL'", "'EXTERNAL_OAUTH_RSA_PUBLIC_KEY'", + "'EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2'", "'EXTERNAL_OAUTH_SCOPE_DELIMITER'", + "'EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE'", "'EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM'", + "'EXTERNAL_OAUTH_TYPE'", "'EXTERNAL_STAGE'", "'FAILOVER'", "'FAILOVER_MODE'", + "'FAIL_OPERATION'", "'FALSE'", "'FETCH'", "'FIELD_DELIMITER'", "'FIELD_OPTIONALLY_ENCLOSED_BY'", + "'FILE'", "'FILES'", "'FILE_EXTENSION'", "'FILE_FORMAT'", "'FILTER'", + "'FIRST'", "'FIRST_NAME'", "'FLATTEN'", "'FOR'", "'FORCE'", "'FOREIGN'", + "'FORMAT'", "'FORMATS'", "'FORMAT_NAME'", "'FREQUENCY'", "'FROM'", "'FULL'", + "'FUNCTION'", "'FUNCTIONS'", "'FUTURE'", "'GCP_PUBSUB'", "'GCP_PUBSUB_SUBSCRIPTION_NAME'", + "'GCP_PUBSUB_TOPIC_NAME'", "'GCS'", "''GENERIC''", "''GENERIC_SCIM_PROVISIONER''", + "'GEO'", "'GEOGRAPHY_OUTPUT_FORMAT'", "'GEOMETRY_OUTPUT_FORMAT'", "'GET'", + "'GET_FILESTREAM_TRANSACTION_CONTEXT'", "'GLOBAL'", "'GOOGLE_AUDIENCE'", + "'GOTO'", "'GRANT'", "'GRANTS'", "'GROUP'", "'GROUPING'", "'GROUPING_ID'", + "'GROUPS'", "'GZIP'", "'HAVING'", "'HEADER'", "'HEADERS'", "'HEX'", + "'HIERARCHYID'", "'HIGH'", "'HISTORY'", "'HOURS'", "'IDENTITY'", "'IF'", + "'IFF'", "'IFNULL'", "'IGNORE'", "'IGNORE_CONSTRAINTS'", "'IGNORE_DUP_KEY'", + "'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX'", "'IGNORE_TRIGGERS'", "'IGNORE_UTF8_ERRORS'", + "'ILIKE'", "'IMMEDIATE'", "'IMMEDIATELY'", "'IMMUTABLE'", "'IMPLICIT'", + "'IMPORT'", "'IMPORTED'", "'IN'", "'INCREMENT'", "'INDEX'", "'INFORMATION'", + "'INIT'", "'INITIALLY'", "'INITIALLY_SUSPENDED'", "'INITIAL_REPLICATION_SIZE_LIMIT_IN_TB'", + "'INNER'", "'INPUT'", "'INSERT'", "'INSERT_ONLY'", "'INSTEAD'", "'INT'", + "'INTEGRATION'", "'INTEGRATIONS'", "'INTERSECT'", "'INTO'", "'IS'", + "'ISNULL'", "'ISNUMERIC'", "'ISOLATION'", "'JAVASCRIPT'", "'JDBC_TREAT_DECIMAL_AS_INT'", + "'JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC'", "'JDBC_USE_SESSION_TIMEZONE'", + "'JOIN'", "'JSON'", "''JSON''", "'JSON_INDENT'", "'JS_TREAT_INTEGER_AS_BIGINT'", + "'KB'", "'KEEP'", "'KEY'", "'KEYS'", "'KEYSET'", "'KMS_KEY_ID'", "'LAG'", + "'LANGUAGE'", "'LARGE'", "'LAST'", "'LAST_NAME'", "'LAST_QUERY_ID'", + "'LAST_VALUE'", "'LATERAL'", "'LEAD'", "'LEFT'", "'LEN'", "'LENGTH'", + "'LEVEL'", "'LIKE'", "'LIMIT'", "'LINENO'", "'LIST'", "'LISTENER_IP'", + "'LISTENER_PORT'", "'LISTING'", "'LOAD'", "'LOCAL'", "'LOCAL_SERVICE_NAME'", + "'LOCATION'", "'LOCKS'", "'LOCK_TIMEOUT'", "'LOG'", "'LOGIN'", "'LOGIN_NAME'", + "'LOOKER'", "'LOW'", "'LOWER'", "'LTRIM'", "'LZO'", "'MANAGE'", "'MANAGED'", + "'MASK'", "'MASKED'", "'MASKING'", "'MASTER'", "'MASTER_KEY'", "'MATCH'", + "'MATCHED'", "'MATCHES'", "'MATCH_BY_COLUMN_NAME'", "'MATCH_RECOGNIZE'", + "'MATERIALIZED'", "'MAX_BATCH_ROWS'", "'MAX_CLUSTER_COUNT'", "'MAX_CONCURRENCY_LEVEL'", + "'MAX_DATA_EXTENSION_TIME_IN_DAYS'", "'MAX_SIZE'", "'MEASURES'", "'MEDIUM'", + "'MEMOIZABLE'", "'MERGE'", "'MIDDLE_NAME'", "'MIN'", "'MINS_TO_BYPASS_MFA'", + "'MINS_TO_UNLOCK'", "'MINUS'", "'MINUTES'", "'MIN_CLUSTER_COUNT'", "'MIN_DATA_RETENTION_TIME_IN_DAYS'", + "'MODE'", "'MODIFIED_AFTER'", "'MODIFY'", "'MONITOR'", "'MONITORS'", + "'MONTHLY'", "'MOVE'", "'MULTI_STATEMENT_COUNT'", "'MULTI_USER'", "'MUST_CHANGE'", + "'MUST_CHANGE_PASSWORD'", "'NAME'", "'NATURAL'", "'NCHAR'", "'NESTED_TRIGGERS'", + "'NETWORK'", "'NETWORK_POLICY'", "'NEVER'", "'NEWID'", "'NEWNAME'", + "'NEWSEQUENTIALID'", "'NEW_ACCOUNT'", "'NEW_BROKER'", "'NEW_PASSWORD'", + "'NEXT'", "'NEXTVAL'", "'NO'", "'NONE'", "''NONE''", "'NORELY'", "'NOT'", + "'NOTIFICATION'", "'NOTIFICATIONS'", "'NOTIFICATION_INTEGRATION'", "'NOTIFICATION_PROVIDER'", + "'NOTIFY'", "'NOTIFY_USERS'", "'NOVALIDATE'", "'NTILE'", "'NULLIF'", + "'NULLS'", "'NULL'", "'NULL_IF'", "'NUMANODE'", "'NUMBER'", "'NUMERIC_ROUNDABORT'", + "'NVL'", "'OAUTH'", "'OAUTH_ALLOW_NON_TLS_REDIRECT_URI'", "'OAUTH_CLIENT'", + "'OAUTH_CLIENT_RSA_PUBLIC_KEY'", "'OAUTH_CLIENT_RSA_PUBLIC_KEY_2'", + "'OAUTH_ENFORCE_PKCE'", "'OAUTH_ISSUE_REFRESH_TOKENS'", "'OAUTH_REDIRECT_URI'", + "'OAUTH_REFRESH_TOKEN_VALIDITY'", "'OAUTH_USE_SECONDARY_ROLES'", "'OBJECT'", + "''OBJECT''", "'OBJECTS'", "'OBJECT_TYPES'", "'OF'", "'OFF'", "'OFFSET'", + "'OFFSETS'", "'OKTA'", "''OKTA_PROVISIONER''", "''OKTA''", "'OLD'", + "'OLD_ACCOUNT'", "'OLD_PASSWORD'", "'OMIT'", "'ON'", "'ONE'", "'ONLINE'", + "'ONLY'", "'ON_ERROR'", "'ON_FAILURE'", "'OPEN'", "'OPERATE'", "'OPERATIONS'", + "'OPTIMIZATION'", "'OPTION'", "'OR'", "'ORC'", "''ORC''", "'ORDER'", + "'ORGADMIN'", "'ORGANIZATION'", "'OUTBOUND'", "'OUTER'", "'OVER'", "'OVERRIDE'", + "'OVERWRITE'", "'OWNER'", "'OWNERSHIP'", "'PAGE'", "'PARALLEL'", "'PARAMETERS'", + "'PARAM_NODE'", "'PARQUET'", "''PARQUET''", "'PARTIAL'", "'PARTITION'", + "'PARTITIONS'", "'PARTITION_TYPE'", "'PASSWORD'", "'PAST'", "'PATH'", + "'PATTERN'", "'PER'", "'PERCENT'", "'PERCENTILE_CONT'", "'PERCENTILE_DISC'", + "'PERCENT_RANK'", "'PERIODIC_DATA_REKEYING'", "'PERMISSION_SET'", "'PERSISTED'", + "'PERSIST_SAMPLE_PERCENT'", "'PING_FEDERATE'", "'PIPE'", "'PIPES'", + "'PIPE_EXECUTION_PAUSED'", "'PIVOT'", "'PLAN'", "'PLATFORM'", "'POLICIES'", + "'POLICY'", "'POOL'", "'PORT'", "'PRECEDING'", "'PRECISION'", "'PREDICATE'", + "'PREFIX'", "'PRESERVE_SPACE'", "'PREVENT_UNLOAD_TO_INLINE_URL'", "'PREVENT_UNLOAD_TO_INTERNAL_STAGES'", + "'PRE_AUTHORIZED_ROLES_LIST'", "'PRIMARY'", "'PRIMARY_ROLE'", "'PRIOR'", + "'PRIORITY'", "'PRIORITY_LEVEL'", "'PRIVATE'", "'PRIVATE_KEY'", "'PRIVILEGES'", + "'PROC'", "'PROCEDURE'", "'PROCEDURES'", "'PROCEDURE_NAME'", "'PROCESS'", + "'PROFILE'", "'PROPERTY'", "'PROVIDER'", "'PROVIDER_KEY_NAME'", "'PUBLIC'", + "'PURGE'", "'PUT'", "'PYTHON'", "'QUALIFY'", "'QUERIES'", "'QUERY'", + "'QUERY_ACCELERATION_MAX_SCALE_FACTOR'", "'QUERY_TAG'", "'QUEUE'", "'QUOTED_IDENTIFIERS_IGNORE_CASE'", + "'RANGE'", "'RANK'", "'RAW_DEFLATE'", "'READ'", "'READER'", "'READONLY'", + "'READPAST'", "'READTEXT'", "'READWRITE'", "'READ_COMMITTED_SNAPSHOT'", + "'READ_ONLY'", "'READ_ONLY_ROUTING_LIST'", "'READ_WRITE'", "'REBUILD'", + "'RECEIVE'", "'RECLUSTER'", "'RECOMPILE'", "'RECONFIGURE'", "'RECORD_DELIMITER'", + "'RECOVERY'", "'RECURSIVE'", "'RECURSIVE_TRIGGERS'", "'REFERENCES'", + "'REFERENCE_USAGE'", "'REFRESH'", "'REFRESH_ON_CREATE'", "'REGION'", + "'REGIONS'", "'REGION_GROUP'", "'RELATIVE'", "'RELY'", "'REMOTE'", "'REMOTE_PROC_TRANSACTIONS'", + "'REMOTE_SERVICE_NAME'", "'REMOVE'", "'RENAME'", "'REPEATABLE'", "'REPLACE'", + "'REPLACE_INVALID_CHARACTERS'", "'REPLICA'", "'REPLICATION'", "'REPLICATION_SCHEDULE'", + "'REQUEST_TRANSLATOR'", "'REQUIRED'", "'REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION'", + "'REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION'", "'RESET'", "'RESOURCE'", + "'RESOURCES'", "'RESOURCE_MONITOR'", "'RESPONSE_TRANSLATOR'", "'RESTART'", + "'RESTORE'", "'RESTRICT'", "'RESTRICTIONS'", "'RESULT'", "'RESUME'", + "'RETAINDAYS'", "'RETURN'", "'RETURNS'", "'RETURN_ALL_ERRORS'", "'RETURN_ERRORS'", + "'RETURN_FAILED_ONLY'", "", "'RETURN_ROWS'", "'REVERSE'", "'REVERT'", + "'REVOKE'", "'REWIND'", "'RIGHT'", "'RLIKE'", "'ROLE'", "'ROLES'", "'ROLLBACK'", + "'ROLLUP'", "'ROOT'", "'ROW'", "'ROWCOUNT'", "'ROWGUID'", "'ROWLOCK'", + "'ROWS'", "'ROWS_PER_RESULTSET'", "'ROW_NUMBER'", "'RSA_PUBLIC_KEY'", + "'RSA_PUBLIC_KEY_2'", "'RTRIM'", "'RUN_AS_ROLE'", "''S3''", "'SAFE'", + "'SAFETY'", "'SAML2'", "'SAML2_ENABLE_SP_INITIATED'", "'SAML2_FORCE_AUTHN'", + "'SAML2_ISSUER'", "'SAML2_POST_LOGOUT_REDIRECT_URL'", "'SAML2_PROVIDER'", + "'SAML2_REQUESTED_NAMEID_FORMAT'", "'SAML2_SIGN_REQUEST'", "'SAML2_SNOWFLAKE_ACS_URL'", + "'SAML2_SNOWFLAKE_ISSUER_URL'", "'SAML2_SNOWFLAKE_X509_CERT'", "'SAML2_SP_INITIATED_LOGIN_PAGE_LABEL'", + "'SAML2_SSO_URL'", "'SAML2_X509_CERT'", "'SAML_IDENTITY_PROVIDER'", + "'SAMPLE'", "'SAVE_OLD_URL'", "'SCALING_POLICY'", "'SCHEDULE'", "'SCHEDULER'", + "'SCHEMA'", "'SCHEMAS'", "'SCHEME'", "'SCIM'", "'SCIM_CLIENT'", "'SCRIPT'", + "'SEARCH'", "'SECONDARY'", "'SECONDARY_ONLY'", "'SECONDARY_ROLE'", "'SECONDS'", + "'SECRET'", "'SECURE'", "'SECURITY'", "'SECURITYADMIN'", "'SEED'", "'SELECT'", + "'SELF'", "'SEQUENCE'", "'SEQUENCES'", "'SERVER'", "'SERVICE'", "'SESSION'", + "'SESSION_IDLE_TIMEOUT_MINS'", "'SESSION_POLICY'", "'SESSION_UI_IDLE_TIMEOUT_MINS'", + "'SET'", "'SETS'", "'SETUSER'", "'SHARE'", "'SHARED'", "'SHARES'", "'SHARE_RESTRICTIONS'", + "'SHOW'", "'SHOWPLAN'", "'SHOWPLAN_ALL'", "'SHOWPLAN_TEXT'", "'SHOWPLAN_XML'", + "'SHOW_INITIAL_ROWS'", "'SIGNATURE'", "'SIMPLE'", "'SIMULATED_DATA_SHARING_CONSUMER'", + "'SINGLE_USER'", "'SIZE'", "'SIZE_LIMIT'", "'SKIP'", "'SKIP_BLANK_LINES'", + "'SKIP_BYTE_ORDER_MARK'", "'SKIP_FILE'", "", "'SKIP_HEADER'", "'SMALL'", + "'SNAPPY'", "'SNAPPY_COMPRESSION'", "'SOME'", "'SOUNDEX'", "'SOURCE'", + "'SOURCE_COMPRESSION'", "'SPACE'", "'SPARSE'", "'SPECIFICATION'", "'SPLIT'", + "'SPLIT_PART'", "'SQL'", "'SSO_LOGIN_PAGE'", "'STAGE'", "'STAGES'", + "'STAGE_COPY_OPTIONS'", "'STAGE_FILE_FORMAT'", "'STANDARD'", "'STANDBY'", + "'START'", "'STARTED'", "'STARTS'", "'START_DATE'", "'START_TIMESTAMP'", + "'STATE'", "'STATEMENT'", "'STATEMENT_QUEUED_TIMEOUT_IN_SECONDS'", "'STATEMENT_TIMEOUT_IN_SECONDS'", + "'STATIC'", "'STATISTICS'", "'STATS'", "'STATS_DATE'", "'STATS_STREAM'", + "'STATUS'", "'STATUSONLY'", "'STDEV'", "'STDEVP'", "'STOP'", "'STOPLIST'", + "'STOPPED'", "'STORAGE'", "'STORAGE_ALLOWED_LOCATIONS'", "'STORAGE_AWS_OBJECT_ACL'", + "'STORAGE_AWS_ROLE_ARN'", "'STORAGE_BLOCKED_LOCATIONS'", "'STORAGE_INTEGRATION'", + "'STORAGE_PROVIDER'", "'STR'", "'STREAM'", "'STREAMS'", "'STRICT'", + "'STRICT_JSON_OUTPUT'", "'STRING_AGG'", "'STRING_ESCAPE'", "'STRIP_NULL_VALUES'", + "'STRIP_OUTER_ARRAY'", "'STRIP_OUTER_ELEMENT'", "'SUBSTR'", "'SUBSTRING'", + "'SUM'", "'SUPPORTED'", "'SUSPEND'", "'SUSPENDED'", "'SUSPEND_IMMEDIATE'", + "'SUSPEND_TASK_AFTER_NUM_FAILURES'", "'SWAP'", "'SWITCH'", "'SYNC_PASSWORD'", + "'SYSADMIN'", "'SYSTEM'", "'SYSTEM_USER'", "'TABLE'", "'TABLEAU_DESKTOP'", + "'TABLEAU_SERVER'", "'TABLES'", "'TABLESAMPLE'", "'TABLE_FORMAT'", "'TABULAR'", + "'TAG'", "'TAGS'", "'TARGET'", "'TARGET_LAG'", "'TASK'", "'TASKS'", + "'TEMP'", "'TEMPORARY'", "'TERSE'", "'TEXTSIZE'", "'THEN'", "'TIES'", + "'TIME'", "'TIMEADD'", "'TIMEDIFF'", "'TIMEOUT'", "'TIMER'", "'TIMESTAMP'", + "'TIMESTAMP_DAY_IS_ALWAYS_24H'", "'TIMESTAMP_FORMAT'", "'TIMESTAMP_INPUT_FORMAT'", + "'TIMESTAMP_LTZ'", "'TIMESTAMP_LTZ_OUTPUT_FORMAT'", "'TIMESTAMP_NTZ'", + "'TIMESTAMP_NTZ_OUTPUT_FORMAT'", "'TIMESTAMP_OUTPUT_FORMAT'", "'TIMESTAMP_TYPE_MAPPING'", + "'TIMESTAMP_TZ'", "'TIMESTAMP_TZ_OUTPUT_FORMAT'", "'TIMESTAMPADD'", + "'TIMESTAMPDIFF'", "'TIMEZONE'", "'TIME_FORMAT'", "'TIME_INPUT_FORMAT'", + "'TIME_OUTPUT_FORMAT'", "'TO'", "'TO_BOOLEAN'", "'TO_DATE'", "'TOP'", + "'TORN_PAGE_DETECTION'", "'TRACKING'", "'TRACK_CAUSALITY'", "'TRAN'", + "'TRANSACTION'", "'TRANSACTIONS'", "'TRANSACTION_ABORT_ON_ERROR'", "'TRANSACTION_DEFAULT_ISOLATION_LEVEL'", + "'TRANSACTION_ID'", "'TRANSFORM_NOISE_WORDS'", "'TRANSIENT'", "'TRANSLATE'", + "'TRIGGER'", "'TRIGGERS'", "'TRIM'", "'TRIM_SPACE'", "'TRIPLE_DES'", + "'TRIPLE_DES_3KEY'", "'TRUE'", "'TRUNCATE'", "'TRUNCATECOLUMNS'", "'TRUSTWORTHY'", + "'TRY'", "'TRY_CAST'", "'TSEQUAL'", "'TSQL'", "'TWO_DIGIT_CENTURY_START'", + "'TWO_DIGIT_YEAR_CUTOFF'", "'TYPE'", "'TYPEPROPERTY'", "'TYPE_ID'", + "'TYPE_NAME'", "'TYPE_WARNING'", "'UN'", "'UNBOUNDED'", "'UNCHECKED'", + "'UNCOMMITTED'", "'UNDROP'", "'UNICODE'", "'UNION'", "'UNIQUE'", "'UNKNOWN'", + "'UNLIMITED'", "'UNLOCK'", "'UNMASK'", "'UNMATCHED'", "'UNPIVOT'", "'UNSAFE'", + "'UNSET'", "'UNSUPPORTED_DDL_ACTION'", "'UOW'", "'UPDATE'", "'UPDLOCK'", + "'UPPER'", "'URL'", "'USAGE'", "'USE'", "'USED'", "'USER'", "'USERADMIN'", + "'USERS'", "'USER_SPECIFIED'", "'USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE'", + "'USER_TASK_TIMEOUT_MS'", "'USE_ANY_ROLE'", "'USE_CACHED_RESULT'", "'USING'", + "'UTF8'", "'VALIDATE'", "'VALIDATION'", "'VALIDATION_MODE'", "'VALID_XML'", + "'VALUE'", "'VALUES'", "'VAR'", "'VARIABLES'", "'VARP'", "'VARYING'", + "'VERSION'", "'VIEW'", "'VIEWS'", "'VIEW_METADATA'", "'VISIBILITY'", + "'VOLATILE'", "'WAIT'", "'WAREHOUSE'", "'WAREHOUSES'", "'WAREHOUSE_SIZE'", + "'WEEKLY'", "'WEEK_OF_YEAR_POLICY'", "'WEEK_START'", "'WELL_FORMED_XML'", + "'WHEN'", "'WHERE'", "'WITH'", "'WITHIN'", "'WITHOUT'", "'WITHOUT_ARRAY_WRAPPER'", + "'WORK'", "'WORKLOAD'", "'WRITE'", "'X4LARGE'", "'X5LARGE'", "'X6LARGE'", + "'XLARGE'", "'XLOCK'", "'XML'", "''XML''", "'XSMALL'", "'XXLARGE'", + "'XXXLARGE'", "'YEARLY'", "'ZSTD'", "'ARRAY'", "''ARRAY''", "'BIGINT'", + "'BINARY'", "'BOOLEAN'", "'BYTEINT'", "'CHAR VARYING'", "'DATE'", "'DATETIME'", + "'DECIMAL'", "'FLOAT4'", "'FLOAT8'", "'FLOAT'", "'GEOGRAPHY'", "'GEOMETRY'", + "'INTEGER'", "'NCHAR VARYING'", "'NUMERIC'", "'NVARCHAR2'", "'NVARCHAR'", + "'REAL'", "'SMALLINT'", "'STRING'", "'TEXT'", "'TINYINT'", "'VARBINARY'", + "'VARCHAR'", "'VARIANT'", "'LISTAGG'", "'DUMMY'", "", "", "", "", "", + "'\"\"'", "'''", "", "", "''s3://''", "''gcs://''", "''azure://''", + "'file://'", "", "", "", "", "", "", "'->'", "'=>'", "'!='", "'<>'", + "'='", "'>'", "'>='", "'<'", "'<='", "'!'", "'||'", "'.'", "'_'", "'@'", + "''@''", "'$'", "'('", "')'", "'['", "']'", "'{'", "'}'", "','", "';'", + "':'", "'::'", "'*'", "'/'", "'%'", "'+'", "'-'", "'?'", + } + staticData.SymbolicNames = []string{ + "", "AAD_PROVISIONER_Q", "ABORT", "ABORT_AFTER_WAIT", "ABORT_DETACHED_QUERY", + "ABORT_STATEMENT", "ABSENT", "ABSOLUTE", "ACCESS", "ACCOUNT", "ACCOUNTADMIN", + "ACCOUNTS", "ACTION", "ACTIVE", "ADD", "ADMINISTER", "ADMIN_NAME", "ADMIN_PASSWORD", + "AES", "AFTER", "AGGREGATE", "ALERT", "ALERTS", "ALL", "ALLOWED", "ALLOWED_ACCOUNTS", + "ALLOWED_DATABASES", "ALLOWED_INTEGRATION_TYPES", "ALLOWED_IP_LIST", + "ALLOWED_SHARES", "ALLOWED_VALUES", "ALLOW_CLIENT_MFA_CACHING", "ALLOW_CONNECTIONS", + "ALLOW_DUPLICATE", "ALLOW_ID_TOKEN", "ALLOW_MULTIPLE_EVENT_LOSS", "ALLOW_OVERLAPPING_EXECUTION", + "ALLOW_SINGLE_EVENT_LOSS", "ALTER", "ALWAYS", "AND", "ANONYMOUS", "ANSI_DEFAULTS", + "ANY", "API", "API_ALLOWED_PREFIXES", "API_AWS_ROLE_ARN", "API_BLOCKED_PREFIXES", + "API_INTEGRATION", "API_KEY", "API_PROVIDER", "APPEND", "APPEND_ONLY", + "APPLICATION", "APPLY", "APP_NAME", "AS", "ASC", "ATTACH", "AT_KEYWORD", + "AUTHORIZATION", "AUTHORIZATIONS", "AUTO", "AUTO_Q", "AUTOCOMMIT", "AUTOCOMMIT_API_SUPPORTED", + "AUTOINCREMENT", "AUTO_COMPRESS", "AUTO_DETECT", "AUTO_INGEST", "AUTO_REFRESH", + "AUTO_RESUME", "AUTO_SUSPEND", "AVG", "AVRO", "AVRO_Q", "AWS_KEY_ID", + "AWS_ROLE", "AWS_SECRET_KEY", "AWS_SNS", "AWS_SNS_ROLE_ARN", "AWS_SNS_TOPIC", + "AWS_SNS_TOPIC_ARN", "AWS_TOKEN", "AZURE", "AZURE_AD_APPLICATION_ID", + "AZURE_EVENT_GRID", "AZURE_EVENT_GRID_TOPIC_ENDPOINT", "AZURE_Q", "AZURE_SAS_TOKEN", + "AZURE_STORAGE_QUEUE_PRIMARY_URI", "AZURE_TENANT_ID", "BASE64", "BEFORE", + "BEGIN", "BERNOULLI", "BETWEEN", "BINARY_AS_TEXT", "BINARY_CHECKSUM", + "BINARY_FORMAT", "BINARY_INPUT_FORMAT", "BINARY_OUTPUT_FORMAT", "BINDING", + "BLOCK", "BLOCKED_IP_LIST", "BLOCKED_ROLES_LIST", "BODY", "BOTH_Q", + "BROTLI", "BUSINESS_CRITICAL", "BY", "BZ2", "CACHE", "CALL", "CALLED", + "CALLER", "CASCADE", "CASE", "CASE_INSENSITIVE", "CASE_SENSITIVE", "CAST", + "CATCH", "CERTIFICATE", "CHANGE", "CHANGES", "CHANGETABLE", "CHANGE_RETENTION", + "CHANGE_TRACKING", "CHAR", "CHARACTER", "CHARINDEX", "CHECK", "CHECKSUM", + "CHECKSUM_AGG", "CHECK_EXPIRATION", "CHECK_POLICY", "CLASSIFIER_FUNCTION", + "CLEANUP", "CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS", "CLIENT_ENCRYPTION_KEY_SIZE", + "CLIENT_MEMORY_LIMIT", "CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX", + "CLIENT_METADATA_USE_SESSION_DATABASE", "CLIENT_PREFETCH_THREADS", "CLIENT_RESULT_CHUNK_SIZE", + "CLIENT_RESULT_COLUMN_CASE_INSENSITIVE", "CLIENT_SESSION_KEEP_ALIVE", + "CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY", "CLIENT_TIMESTAMP_TYPE_MAPPING", + "CLONE", "CLOSE", "CLUSTER", "CLUSTERED", "CLUSTERING", "COALESCE", + "COLLATE", "COLLECTION", "COLUMN", "COLUMNS", "COL_LENGTH", "COL_NAME", + "COMMENT", "COMMIT", "COMMITTED", "COMPRESS", "COMPRESSION", "CONCAT", + "CONCAT_NULL_YIELDS_NULL", "CONCAT_WS", "CONDITION", "CONFIGURATION", + "CONNECT", "CONNECTION", "CONNECTIONS", "CONSTRAINT", "CONTAINMENT", + "CONTAINS", "CONTENT", "CONTEXT", "CONTEXT_HEADERS", "CONTEXT_INFO", + "CONTINUE", "CONTROL", "CONVERSATION", "COOKIE", "COPY", "COPY_ONLY", + "COPY_OPTIONS_", "COUNT", "COUNT_BIG", "CREATE", "CREDENTIALS", "CREDIT_QUOTA", + "CROSS", "CSV", "CSV_Q", "CUBE", "CUME_DIST", "CURRENT", "CURRENT_DATE", + "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", "CURSOR", "CUSTOM", + "DAILY", "DATA", "DATABASE", "DATABASES", "DATA_RETENTION_TIME_IN_DAYS", + "DATEADD", "DATEDIFF", "DATENAME", "DATEPART", "DATE_FORMAT", "DATE_INPUT_FORMAT", + "DATE_OUTPUT_FORMAT", "DATE_PART", "DAYS", "DAYS_TO_EXPIRY", "DECLARE", + "DEFAULT", "DEFAULT_DDL_COLLATION_", "DEFAULT_NAMESPACE", "DEFAULT_ROLE", + "DEFAULT_WAREHOUSE", "DEFERRABLE", "DEFERRED", "DEFINE", "DEFINITION", + "DEFLATE", "DELEGATED", "DELETE", "DELTA", "DENSE_RANK", "DESC", "DESCRIBE", + "DIRECTION", "DIRECTORY", "DISABLE", "DISABLED", "DISABLE_AUTO_CONVERT", + "DISABLE_SNOWFLAKE_DATA", "DISK", "DISPLAY_NAME", "DISTINCT", "DO", + "DOWNSTREAM", "DOUBLE", "DROP", "DYNAMIC", "ECONOMY", "EDITION", "ELSE", + "EMAIL", "EMPTY_", "EMPTY_FIELD_AS_NULL", "ENABLE", "ENABLED", "ENABLE_FOR_PRIVILEGE", + "ENABLE_INTERNAL_STAGES_PRIVATELINK", "ENABLE_OCTAL", "ENABLE_QUERY_ACCELERATION", + "ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION", "ENCODING", "ENCRYPTION", + "END", "ENDPOINT", "END_TIMESTAMP", "ENFORCED", "ENFORCE_LENGTH", "ENFORCE_SESSION_POLICY", + "ENTERPRISE", "EQUALITY", "ERROR_INTEGRATION", "ERROR_ON_COLUMN_COUNT_MISMATCH", + "ERROR_ON_NONDETERMINISTIC_MERGE", "ERROR_ON_NONDETERMINISTIC_UPDATE", + "ESCAPE", "ESCAPE_UNENCLOSED_FIELD", "EXCEPT", "EXCHANGE", "EXECUTE", + "EXECUTION", "EXIST", "EXISTS", "EXIT", "EXPAND", "EXPIRY_DATE", "EXPLAIN", + "EXPLICIT", "EXTERNAL", "EXTERNAL_OAUTH", "EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST", + "EXTERNAL_OAUTH_ALLOWED_ROLES_LIST", "EXTERNAL_OAUTH_ANY_ROLE_MODE", + "EXTERNAL_OAUTH_AUDIENCE_LIST", "EXTERNAL_OAUTH_BLOCKED_ROLES_LIST", + "EXTERNAL_OAUTH_ISSUER", "EXTERNAL_OAUTH_JWS_KEYS_URL", "EXTERNAL_OAUTH_RSA_PUBLIC_KEY", + "EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2", "EXTERNAL_OAUTH_SCOPE_DELIMITER", + "EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE", "EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM", + "EXTERNAL_OAUTH_TYPE", "EXTERNAL_STAGE", "FAILOVER", "FAILOVER_MODE", + "FAIL_OPERATION", "FALSE", "FETCH", "FIELD_DELIMITER", "FIELD_OPTIONALLY_ENCLOSED_BY", + "FILE", "FILES", "FILE_EXTENSION", "FILE_FORMAT", "FILTER", "FIRST", + "FIRST_NAME", "FLATTEN", "FOR", "FORCE", "FOREIGN", "FORMAT", "FORMATS", + "FORMAT_NAME", "FREQUENCY", "FROM", "FULL", "FUNCTION", "FUNCTIONS", + "FUTURE", "GCP_PUBSUB", "GCP_PUBSUB_SUBSCRIPTION_NAME", "GCP_PUBSUB_TOPIC_NAME", + "GCS", "GENERIC_Q", "GENERIC_SCIM_PROVISIONER_Q", "GEO", "GEOGRAPHY_OUTPUT_FORMAT", + "GEOMETRY_OUTPUT_FORMAT", "GET", "GET_FILESTREAM_TRANSACTION_CONTEXT", + "GLOBAL", "GOOGLE_AUDIENCE", "GOTO", "GRANT", "GRANTS", "GROUP", "GROUPING", + "GROUPING_ID", "GROUPS", "GZIP", "HAVING", "HEADER", "HEADERS", "HEX", + "HIERARCHYID", "HIGH", "HISTORY", "HOURS", "IDENTITY", "IF", "IFF", + "IFNULL", "IGNORE", "IGNORE_CONSTRAINTS", "IGNORE_DUP_KEY", "IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX", + "IGNORE_TRIGGERS", "IGNORE_UTF8_ERRORS", "ILIKE", "IMMEDIATE", "IMMEDIATELY", + "IMMUTABLE", "IMPLICIT", "IMPORT", "IMPORTED", "IN", "INCREMENT", "INDEX", + "INFORMATION", "INIT", "INITIALLY", "INITIALLY_SUSPENDED", "INITIAL_REPLICATION_SIZE_LIMIT_IN_TB", + "INNER", "INPUT", "INSERT", "INSERT_ONLY", "INSTEAD", "INT", "INTEGRATION", + "INTEGRATIONS", "INTERSECT", "INTO", "IS", "ISNULL", "ISNUMERIC", "ISOLATION", + "JAVASCRIPT", "JDBC_TREAT_DECIMAL_AS_INT", "JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC", + "JDBC_USE_SESSION_TIMEZONE", "JOIN", "JSON", "JSON_Q", "JSON_INDENT", + "JS_TREAT_INTEGER_AS_BIGINT", "KB", "KEEP", "KEY", "KEYS", "KEYSET", + "KMS_KEY_ID", "LAG", "LANGUAGE", "LARGE", "LAST", "LAST_NAME", "LAST_QUERY_ID", + "LAST_VALUE", "LATERAL", "LEAD", "LEFT", "LEN", "LENGTH", "LEVEL", "LIKE", + "LIMIT", "LINENO", "LIST", "LISTENER_IP", "LISTENER_PORT", "LISTING", + "LOAD", "LOCAL", "LOCAL_SERVICE_NAME", "LOCATION", "LOCKS", "LOCK_TIMEOUT", + "LOG", "LOGIN", "LOGIN_NAME", "LOOKER", "LOW", "LOWER", "LTRIM", "LZO", + "MANAGE", "MANAGED", "MASK", "MASKED", "MASKING", "MASTER", "MASTER_KEY", + "MATCH", "MATCHED", "MATCHES", "MATCH_BY_COLUMN_NAME", "MATCH_RECOGNIZE", + "MATERIALIZED", "MAX_BATCH_ROWS", "MAX_CLUSTER_COUNT", "MAX_CONCURRENCY_LEVEL", + "MAX_DATA_EXTENSION_TIME_IN_DAYS", "MAX_SIZE", "MEASURES", "MEDIUM", + "MEMOIZABLE", "MERGE", "MIDDLE_NAME", "MIN", "MINS_TO_BYPASS_MFA", "MINS_TO_UNLOCK", + "MINUS_", "MINUTES", "MIN_CLUSTER_COUNT", "MIN_DATA_RETENTION_TIME_IN_DAYS", + "MODE", "MODIFIED_AFTER", "MODIFY", "MONITOR", "MONITORS", "MONTHLY", + "MOVE", "MULTI_STATEMENT_COUNT", "MULTI_USER", "MUST_CHANGE", "MUST_CHANGE_PASSWORD", + "NAME", "NATURAL", "NCHAR", "NESTED_TRIGGERS", "NETWORK", "NETWORK_POLICY", + "NEVER", "NEWID", "NEWNAME", "NEWSEQUENTIALID", "NEW_ACCOUNT", "NEW_BROKER", + "NEW_PASSWORD", "NEXT", "NEXTVAL", "NO", "NONE", "NONE_Q", "NORELY", + "NOT", "NOTIFICATION", "NOTIFICATIONS", "NOTIFICATION_INTEGRATION", + "NOTIFICATION_PROVIDER", "NOTIFY", "NOTIFY_USERS", "NOVALIDATE", "NTILE", + "NULLIF", "NULLS", "NULL_", "NULL_IF", "NUMANODE", "NUMBER", "NUMERIC_ROUNDABORT", + "NVL", "OAUTH", "OAUTH_ALLOW_NON_TLS_REDIRECT_URI", "OAUTH_CLIENT", + "OAUTH_CLIENT_RSA_PUBLIC_KEY", "OAUTH_CLIENT_RSA_PUBLIC_KEY_2", "OAUTH_ENFORCE_PKCE", + "OAUTH_ISSUE_REFRESH_TOKENS", "OAUTH_REDIRECT_URI", "OAUTH_REFRESH_TOKEN_VALIDITY", + "OAUTH_USE_SECONDARY_ROLES", "OBJECT", "OBJECT_Q", "OBJECTS", "OBJECT_TYPES", + "OF", "OFF", "OFFSET", "OFFSETS", "OKTA", "OKTA_PROVISIONER_Q", "OKTA_Q", + "OLD", "OLD_ACCOUNT", "OLD_PASSWORD", "OMIT", "ON", "ONE", "ONLINE", + "ONLY", "ON_ERROR", "ON_FAILURE", "OPEN", "OPERATE", "OPERATIONS", "OPTIMIZATION", + "OPTION", "OR", "ORC", "ORC_Q", "ORDER", "ORGADMIN", "ORGANIZATION", + "OUTBOUND", "OUTER", "OVER", "OVERRIDE", "OVERWRITE", "OWNER", "OWNERSHIP", + "PAGE", "PARALLEL", "PARAMETERS", "PARAM_NODE", "PARQUET", "PARQUET_Q", + "PARTIAL", "PARTITION", "PARTITIONS", "PARTITION_TYPE", "PASSWORD", + "PAST", "PATH_", "PATTERN", "PER", "PERCENT", "PERCENTILE_CONT", "PERCENTILE_DISC", + "PERCENT_RANK", "PERIODIC_DATA_REKEYING", "PERMISSION_SET", "PERSISTED", + "PERSIST_SAMPLE_PERCENT", "PING_FEDERATE", "PIPE", "PIPES", "PIPE_EXECUTION_PAUSED", + "PIVOT", "PLAN", "PLATFORM", "POLICIES", "POLICY", "POOL", "PORT", "PRECEDING", + "PRECISION", "PREDICATE", "PREFIX", "PRESERVE_SPACE", "PREVENT_UNLOAD_TO_INLINE_URL", + "PREVENT_UNLOAD_TO_INTERNAL_STAGES", "PRE_AUTHORIZED_ROLES_LIST", "PRIMARY", + "PRIMARY_ROLE", "PRIOR", "PRIORITY", "PRIORITY_LEVEL", "PRIVATE", "PRIVATE_KEY", + "PRIVILEGES", "PROC", "PROCEDURE", "PROCEDURES", "PROCEDURE_NAME", "PROCESS", + "PROFILE", "PROPERTY", "PROVIDER", "PROVIDER_KEY_NAME", "PUBLIC", "PURGE", + "PUT", "PYTHON", "QUALIFY", "QUERIES", "QUERY", "QUERY_ACCELERATION_MAX_SCALE_FACTOR", + "QUERY_TAG", "QUEUE", "QUOTED_IDENTIFIERS_IGNORE_CASE", "RANGE", "RANK", + "RAW_DEFLATE", "READ", "READER", "READONLY", "READPAST", "READTEXT", + "READWRITE", "READ_COMMITTED_SNAPSHOT", "READ_ONLY", "READ_ONLY_ROUTING_LIST", + "READ_WRITE", "REBUILD", "RECEIVE", "RECLUSTER", "RECOMPILE", "RECONFIGURE", + "RECORD_DELIMITER", "RECOVERY", "RECURSIVE", "RECURSIVE_TRIGGERS", "REFERENCES", + "REFERENCE_USAGE", "REFRESH", "REFRESH_ON_CREATE", "REGION", "REGIONS", + "REGION_GROUP", "RELATIVE", "RELY", "REMOTE", "REMOTE_PROC_TRANSACTIONS", + "REMOTE_SERVICE_NAME", "REMOVE", "RENAME", "REPEATABLE", "REPLACE", + "REPLACE_INVALID_CHARACTERS", "REPLICA", "REPLICATION", "REPLICATION_SCHEDULE", + "REQUEST_TRANSLATOR", "REQUIRED", "REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION", + "REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION", "RESET", "RESOURCE", + "RESOURCES", "RESOURCE_MONITOR", "RESPONSE_TRANSLATOR", "RESTART", "RESTORE", + "RESTRICT", "RESTRICTIONS", "RESULT", "RESUME", "RETAINDAYS", "RETURN", + "RETURNS", "RETURN_ALL_ERRORS", "RETURN_ERRORS", "RETURN_FAILED_ONLY", + "RETURN_N_ROWS", "RETURN_ROWS", "REVERSE", "REVERT", "REVOKE", "REWIND", + "RIGHT", "RLIKE", "ROLE", "ROLES", "ROLLBACK", "ROLLUP", "ROOT", "ROW", + "ROWCOUNT", "ROWGUID", "ROWLOCK", "ROWS", "ROWS_PER_RESULTSET", "ROW_NUMBER", + "RSA_PUBLIC_KEY", "RSA_PUBLIC_KEY_2", "RTRIM", "RUN_AS_ROLE", "S3", + "SAFE", "SAFETY", "SAML2", "SAML2_ENABLE_SP_INITIATED", "SAML2_FORCE_AUTHN", + "SAML2_ISSUER", "SAML2_POST_LOGOUT_REDIRECT_URL", "SAML2_PROVIDER", + "SAML2_REQUESTED_NAMEID_FORMAT", "SAML2_SIGN_REQUEST", "SAML2_SNOWFLAKE_ACS_URL", + "SAML2_SNOWFLAKE_ISSUER_URL", "SAML2_SNOWFLAKE_X509_CERT", "SAML2_SP_INITIATED_LOGIN_PAGE_LABEL", + "SAML2_SSO_URL", "SAML2_X509_CERT", "SAML_IDENTITY_PROVIDER", "SAMPLE", + "SAVE_OLD_URL", "SCALING_POLICY", "SCHEDULE", "SCHEDULER", "SCHEMA", + "SCHEMAS", "SCHEME", "SCIM", "SCIM_CLIENT", "SCRIPT", "SEARCH", "SECONDARY", + "SECONDARY_ONLY", "SECONDARY_ROLE", "SECONDS", "SECRET", "SECURE", "SECURITY", + "SECURITYADMIN", "SEED", "SELECT", "SELF", "SEQUENCE", "SEQUENCES", + "SERVER", "SERVICE", "SESSION", "SESSION_IDLE_TIMEOUT_MINS", "SESSION_POLICY", + "SESSION_UI_IDLE_TIMEOUT_MINS", "SET", "SETS", "SETUSER", "SHARE", "SHARED", + "SHARES", "SHARE_RESTRICTIONS", "SHOW", "SHOWPLAN", "SHOWPLAN_ALL", + "SHOWPLAN_TEXT", "SHOWPLAN_XML", "SHOW_INITIAL_ROWS", "SIGNATURE", "SIMPLE", + "SIMULATED_DATA_SHARING_CONSUMER", "SINGLE_USER", "SIZE", "SIZE_LIMIT", + "SKIP_", "SKIP_BLANK_LINES", "SKIP_BYTE_ORDER_MARK", "SKIP_FILE", "SKIP_FILE_N", + "SKIP_HEADER", "SMALL", "SNAPPY", "SNAPPY_COMPRESSION", "SOME", "SOUNDEX", + "SOURCE", "SOURCE_COMPRESSION", "SPACE_KEYWORD", "SPARSE", "SPECIFICATION", + "SPLIT", "SPLIT_PART", "SQL", "SSO_LOGIN_PAGE", "STAGE", "STAGES", "STAGE_COPY_OPTIONS", + "STAGE_FILE_FORMAT", "STANDARD", "STANDBY", "START", "STARTED", "STARTS", + "START_DATE", "START_TIMESTAMP", "STATE", "STATEMENT", "STATEMENT_QUEUED_TIMEOUT_IN_SECONDS", + "STATEMENT_TIMEOUT_IN_SECONDS", "STATIC", "STATISTICS", "STATS", "STATS_DATE", + "STATS_STREAM", "STATUS", "STATUSONLY", "STDEV", "STDEVP", "STOP", "STOPLIST", + "STOPPED", "STORAGE", "STORAGE_ALLOWED_LOCATIONS", "STORAGE_AWS_OBJECT_ACL", + "STORAGE_AWS_ROLE_ARN", "STORAGE_BLOCKED_LOCATIONS", "STORAGE_INTEGRATION", + "STORAGE_PROVIDER", "STR", "STREAM", "STREAMS", "STRICT", "STRICT_JSON_OUTPUT", + "STRING_AGG", "STRING_ESCAPE", "STRIP_NULL_VALUES", "STRIP_OUTER_ARRAY", + "STRIP_OUTER_ELEMENT", "SUBSTR", "SUBSTRING", "SUM", "SUPPORTED", "SUSPEND", + "SUSPENDED", "SUSPEND_IMMEDIATE", "SUSPEND_TASK_AFTER_NUM_FAILURES", + "SWAP", "SWITCH", "SYNC_PASSWORD", "SYSADMIN", "SYSTEM", "SYSTEM_USER", + "TABLE", "TABLEAU_DESKTOP", "TABLEAU_SERVER", "TABLES", "TABLESAMPLE", + "TABLE_FORMAT", "TABULAR", "TAG", "TAGS", "TARGET", "TARGET_LAG", "TASK", + "TASKS", "TEMP", "TEMPORARY", "TERSE", "TEXTSIZE", "THEN", "TIES", "TIME", + "TIMEADD", "TIMEDIFF", "TIMEOUT", "TIMER", "TIMESTAMP", "TIMESTAMP_DAY_IS_ALWAYS_24H", + "TIMESTAMP_FORMAT", "TIMESTAMP_INPUT_FORMAT", "TIMESTAMP_LTZ", "TIMESTAMP_LTZ_OUTPUT_FORMAT", + "TIMESTAMP_NTZ", "TIMESTAMP_NTZ_OUTPUT_FORMAT", "TIMESTAMP_OUTPUT_FORMAT", + "TIMESTAMP_TYPE_MAPPING", "TIMESTAMP_TZ", "TIMESTAMP_TZ_OUTPUT_FORMAT", + "TIMESTAMPADD", "TIMESTAMPDIFF", "TIMEZONE", "TIME_FORMAT", "TIME_INPUT_FORMAT", + "TIME_OUTPUT_FORMAT", "TO", "TO_BOOLEAN", "TO_DATE", "TOP", "TORN_PAGE_DETECTION", + "TRACKING", "TRACK_CAUSALITY", "TRAN", "TRANSACTION", "TRANSACTIONS", + "TRANSACTION_ABORT_ON_ERROR", "TRANSACTION_DEFAULT_ISOLATION_LEVEL", + "TRANSACTION_ID", "TRANSFORM_NOISE_WORDS", "TRANSIENT", "TRANSLATE", + "TRIGGER", "TRIGGERS", "TRIM", "TRIM_SPACE", "TRIPLE_DES", "TRIPLE_DES_3KEY", + "TRUE", "TRUNCATE", "TRUNCATECOLUMNS", "TRUSTWORTHY", "TRY", "TRY_CAST", + "TSEQUAL", "TSQL", "TWO_DIGIT_CENTURY_START", "TWO_DIGIT_YEAR_CUTOFF", + "TYPE", "TYPEPROPERTY", "TYPE_ID", "TYPE_NAME", "TYPE_WARNING", "UN", + "UNBOUNDED", "UNCHECKED", "UNCOMMITTED", "UNDROP", "UNICODE", "UNION", + "UNIQUE", "UNKNOWN", "UNLIMITED", "UNLOCK", "UNMASK", "UNMATCHED", "UNPIVOT", + "UNSAFE", "UNSET", "UNSUPPORTED_DDL_ACTION", "UOW", "UPDATE", "UPDLOCK", + "UPPER", "URL", "USAGE", "USE", "USED", "USER", "USERADMIN", "USERS", + "USER_SPECIFIED", "USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE", "USER_TASK_TIMEOUT_MS", + "USE_ANY_ROLE", "USE_CACHED_RESULT", "USING", "UTF8", "VALIDATE", "VALIDATION", + "VALIDATION_MODE", "VALID_XML", "VALUE", "VALUES", "VAR", "VARIABLES", + "VARP", "VARYING", "VERSION", "VIEW", "VIEWS", "VIEW_METADATA", "VISIBILITY", + "VOLATILE", "WAIT", "WAREHOUSE", "WAREHOUSES", "WAREHOUSE_SIZE", "WEEKLY", + "WEEK_OF_YEAR_POLICY", "WEEK_START", "WELL_FORMED_XML", "WHEN", "WHERE", + "WITH", "WITHIN", "WITHOUT", "WITHOUT_ARRAY_WRAPPER", "WORK", "WORKLOAD", + "WRITE", "X4LARGE", "X5LARGE", "X6LARGE", "XLARGE", "XLOCK", "XML", + "XML_Q", "XSMALL", "XXLARGE", "XXXLARGE", "YEARLY", "ZSTD", "ARRAY", + "ARRAY_Q", "BIGINT", "BINARY", "BOOLEAN", "BYTEINT", "CHAR_VARYING", + "DATE", "DATETIME", "DECIMAL_", "FLOAT4", "FLOAT8", "FLOAT_", "GEOGRAPHY", + "GEOMETRY", "INTEGER", "NCHAR_VARYING", "NUMERIC", "NVARCHAR2", "NVARCHAR", + "REAL_", "SMALLINT", "STRING_", "TEXT", "TINYINT", "VARBINARY", "VARCHAR", + "VARIANT", "LISTAGG", "DUMMY", "SPACE", "SQL_COMMENT", "LINE_COMMENT", + "LINE_COMMENT_2", "DOUBLE_QUOTE_ID", "DOUBLE_QUOTE_BLANK", "SINGLE_QUOTE", + "ID", "ID2", "S3_PATH", "GCS_PATH", "AZURE_PATH", "FILE_PATH", "DBL_DOLLAR", + "STRING", "DECIMAL", "FLOAT", "REAL", "CHAR_LITERAL", "ARROW", "ASSOC", + "NE", "LTGT", "EQ", "GT", "GE", "LT", "LE", "EXCLAMATION", "PIPE_PIPE", + "DOT", "UNDERLINE", "AT", "AT_Q", "DOLLAR", "LR_BRACKET", "RR_BRACKET", + "LSB", "RSB", "LCB", "RCB", "COMMA", "SEMI", "COLON", "COLON_COLON", + "STAR", "DIVIDE", "MODULE", "PLUS", "MINUS", "PLACEHOLDER", + } + staticData.RuleNames = []string{ + "snowflake_file", "batch", "sql_command", "ddl_command", "dml_command", + "insert_statement", "insert_multi_table_statement", "into_clause2", + "values_list", "value_item", "merge_statement", "merge_matches", "merge_update_delete", + "merge_insert", "update_statement", "table_or_query", "delete_statement", + "values_builder", "other_command", "copy_into_table", "external_location", + "files", "file_format", "format_name", "format_type", "stage_file_format", + "copy_into_location", "comment", "commit", "execute_immediate", "execute_task", + "explain", "parallel", "get_dml", "grant_ownership", "grant_to_role", + "global_privileges", "global_privilege", "account_object_privileges", + "account_object_privilege", "schema_privileges", "schema_privilege", + "schema_object_privileges", "schema_object_privilege", "grant_to_share", + "object_privilege", "grant_role", "role_name", "system_defined_role", + "list", "internal_stage", "external_stage", "put", "remove", "revoke_from_role", + "revoke_from_share", "revoke_role", "rollback", "set", "truncate_materialized_view", + "truncate_table", "unset", "alter_command", "account_params", "object_params", + "default_ddl_collation", "object_properties", "session_params", "alter_account", + "enabled_true_false", "alter_alert", "resume_suspend", "alert_set_clause", + "alert_unset_clause", "alter_api_integration", "api_integration_property", + "alter_connection", "alter_database", "database_property", "account_id_list", + "alter_dynamic_table", "alter_external_table", "ignore_edition_check", + "replication_schedule", "db_name_list", "share_name_list", "full_acct_list", + "alter_failover_group", "alter_file_format", "alter_function", "alter_function_signature", + "data_type_list", "alter_masking_policy", "alter_materialized_view", + "alter_network_policy", "alter_notification_integration", "alter_pipe", + "alter_procedure", "alter_replication_group", "credit_quota", "frequency", + "notify_users", "triggerDefinition", "alter_resource_monitor", "alter_role", + "alter_row_access_policy", "alter_schema", "schema_property", "alter_security_integration", + "alter_security_integration_external_oauth", "security_integration_external_oauth_property", + "alter_security_integration_snowflake_oauth", "security_integration_snowflake_oauth_property", + "alter_security_integration_saml2", "alter_security_integration_scim", + "security_integration_scim_property", "alter_sequence", "alter_session", + "alter_session_policy", "alter_share", "alter_stage", "alter_storage_integration", + "alter_stream", "alter_table", "clustering_action", "table_column_action", + "inline_constraint", "constraint_properties", "ext_table_column_action", + "constraint_action", "search_optimization_action", "search_method_with_target", + "alter_table_alter_column", "alter_column_decl_list", "alter_column_decl", + "alter_column_opts", "column_set_tags", "column_unset_tags", "alter_tag", + "alter_task", "alter_user", "alter_view", "alter_modify", "alter_warehouse", + "alter_connection_opts", "alter_user_opts", "alter_tag_opts", "alter_network_policy_opts", + "alter_warehouse_opts", "alter_account_opts", "set_tags", "tag_decl_list", + "unset_tags", "create_command", "create_account", "create_alert", "alert_condition", + "alert_action", "create_api_integration", "create_object_clone", "create_connection", + "create_database", "create_dynamic_table", "clone_at_before", "at_before1", + "header_decl", "compression_type", "compression", "create_external_function", + "create_external_table", "external_table_column_decl", "external_table_column_decl_list", + "full_acct", "integration_type_name", "create_failover_group", "type_fileformat", + "create_file_format", "arg_decl", "col_decl", "function_definition", + "create_function", "create_managed_account", "create_masking_policy", + "tag_decl", "column_list_in_parentheses", "create_materialized_view", + "create_network_policy", "cloud_provider_params_auto", "cloud_provider_params_push", + "create_notification_integration", "create_pipe", "caller_owner", "executa_as", + "procedure_definition", "create_procedure", "create_replication_group", + "create_resource_monitor", "create_role", "create_row_access_policy", + "create_schema", "create_security_integration_external_oauth", "implicit_none", + "create_security_integration_snowflake_oauth", "create_security_integration_saml2", + "create_security_integration_scim", "network_policy", "partner_application", + "start_with", "increment_by", "create_sequence", "create_session_policy", + "create_share", "character", "format_type_options", "copy_options", + "internal_stage_params", "stage_type", "stage_master_key", "stage_kms_key", + "stage_encryption_opts_aws", "aws_token", "aws_key_id", "aws_secret_key", + "aws_role", "external_stage_params", "true_false", "enable", "refresh_on_create", + "auto_refresh", "notification_integration", "directory_table_params", + "create_stage", "cloud_provider_params", "cloud_provider_params2", "cloud_provider_params3", + "create_storage_integration", "copy_grants", "append_only", "insert_only", + "show_initial_rows", "stream_time", "create_stream", "temporary", "table_type", + "with_tags", "with_row_access_policy", "cluster_by", "change_tracking", + "with_masking_policy", "collate", "not_null", "default_value", "foreign_key", + "out_of_line_constraint", "full_col_decl", "column_decl_item", "column_decl_item_list", + "create_table", "create_table_as_select", "create_tag", "session_parameter", + "session_parameter_list", "session_parameter_init_list", "session_parameter_init", + "create_task", "sql", "call", "create_user", "view_col", "create_view", + "create_warehouse", "wh_properties", "wh_params", "trigger_definition", + "object_type_name", "object_type_plural", "drop_command", "drop_object", + "drop_alert", "drop_connection", "drop_database", "drop_dynamic_table", + "drop_external_table", "drop_failover_group", "drop_file_format", "drop_function", + "drop_integration", "drop_managed_account", "drop_masking_policy", "drop_materialized_view", + "drop_network_policy", "drop_pipe", "drop_procedure", "drop_replication_group", + "drop_resource_monitor", "drop_role", "drop_row_access_policy", "drop_schema", + "drop_sequence", "drop_session_policy", "drop_share", "drop_stage", + "drop_stream", "drop_table", "drop_tag", "drop_task", "drop_user", "drop_view", + "drop_warehouse", "cascade_restrict", "arg_types", "undrop_command", + "undrop_database", "undrop_dynamic_table", "undrop_schema", "undrop_table", + "undrop_tag", "use_command", "use_database", "use_role", "use_schema", + "use_secondary_roles", "use_warehouse", "comment_clause", "if_suspended", + "if_exists", "if_not_exists", "or_replace", "describe", "describe_command", + "describe_alert", "describe_database", "describe_dynamic_table", "describe_external_table", + "describe_file_format", "describe_function", "describe_integration", + "describe_masking_policy", "describe_materialized_view", "describe_network_policy", + "describe_pipe", "describe_procedure", "describe_result", "describe_row_access_policy", + "describe_schema", "describe_search_optimization", "describe_sequence", + "describe_session_policy", "describe_share", "describe_stage", "describe_stream", + "describe_table", "describe_task", "describe_transaction", "describe_user", + "describe_view", "describe_warehouse", "show_command", "show_alerts", + "show_columns", "show_connections", "starts_with", "limit_rows", "show_databases", + "show_databases_in_failover_group", "show_databases_in_replication_group", + "show_delegated_authorizations", "show_external_functions", "show_dynamic_tables", + "show_external_tables", "show_failover_groups", "show_file_formats", + "show_functions", "show_global_accounts", "show_grants", "show_grants_opts", + "show_integrations", "show_locks", "show_managed_accounts", "show_masking_policies", + "in_obj", "in_obj_2", "show_materialized_views", "show_network_policies", + "show_objects", "show_organization_accounts", "in_for", "show_parameters", + "show_pipes", "show_primary_keys", "show_procedures", "show_regions", + "show_replication_accounts", "show_replication_databases", "show_replication_groups", + "show_resource_monitors", "show_roles", "show_row_access_policies", + "show_schemas", "show_sequences", "show_session_policies", "show_shares", + "show_shares_in_failover_group", "show_shares_in_replication_group", + "show_stages", "show_streams", "show_tables", "show_tags", "show_tasks", + "show_transactions", "show_user_functions", "show_users", "show_variables", + "show_views", "show_warehouses", "like_pattern", "account_identifier", + "schema_name", "object_type", "object_type_list", "tag_value", "arg_data_type", + "arg_name", "param_name", "region_group_id", "snowflake_region_id", + "string", "string_list", "id_", "keyword", "non_reserved_words", "builtin_function", + "list_operator", "binary_builtin_function", "binary_or_ternary_builtin_function", + "ternary_builtin_function", "pattern", "column_name", "column_list", + "object_name", "num", "expr_list", "expr_list_sorted", "expr", "iff_expr", + "trim_expression", "try_cast_expr", "json_literal", "kv_pair", "value", + "arr_literal", "data_type", "primitive_expression", "order_by_expr", + "asc_desc", "over_clause", "function_call", "ranking_windowed_function", + "aggregate_function", "literal", "sign", "full_column_name", "bracket_expression", + "case_expression", "switch_search_condition_section", "switch_section", + "query_statement", "with_expression", "common_table_expression", "anchor_clause", + "recursive_clause", "select_statement", "set_operators", "select_optional_clauses", + "select_clause", "select_top_clause", "select_list_no_top", "select_list_top", + "select_list", "select_list_elem", "column_elem", "as_alias", "expression_elem", + "column_position", "all_distinct", "top_clause", "into_clause", "var_list", + "var", "from_clause", "table_sources", "table_source", "table_source_item_joined", + "object_ref", "flatten_table_option", "flatten_table", "prior_list", + "prior_item", "outer_join", "join_type", "join_clause", "at_before", + "end", "changes", "default_append_only", "partition_by", "alias", "expr_alias_list", + "measures", "match_opts", "row_match", "first_last", "symbol", "after_match", + "symbol_list", "define", "match_recognize", "pivot_unpivot", "column_alias_list_in_brackets", + "expr_list_in_parentheses", "values", "sample_method", "repeatable_seed", + "sample_opts", "sample", "search_condition", "comparison_operator", + "null_not_null", "subquery", "predicate", "where_clause", "group_item", + "group_by_clause", "having_clause", "qualify_clause", "order_item", + "order_by_clause", "row_rows", "first_next", "limit_clause", "supplement_non_reserved_words", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 1119, 11949, 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, 1, 0, 1, 0, 1, 0, 5, 0, 1086, 8, 0, 10, 0, 12, 0, 1089, 9, 0, 1, 0, + 3, 0, 1092, 8, 0, 3, 0, 1094, 8, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, + 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1106, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, + 1112, 8, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 1120, 8, 4, 1, 5, + 1, 5, 3, 5, 1124, 8, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 1132, + 8, 5, 1, 5, 1, 5, 3, 5, 1136, 8, 5, 1, 6, 1, 6, 3, 6, 1140, 8, 6, 1, 6, + 1, 6, 1, 6, 1, 6, 3, 6, 1146, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 4, 6, + 1153, 8, 6, 11, 6, 12, 6, 1154, 4, 6, 1157, 8, 6, 11, 6, 12, 6, 1158, 1, + 6, 1, 6, 3, 6, 1163, 8, 6, 1, 6, 1, 6, 3, 6, 1167, 8, 6, 1, 7, 1, 7, 1, + 7, 1, 7, 1, 7, 1, 7, 3, 7, 1175, 8, 7, 1, 7, 3, 7, 1178, 8, 7, 1, 8, 1, + 8, 1, 8, 1, 8, 1, 8, 5, 8, 1185, 8, 8, 10, 8, 12, 8, 1188, 9, 8, 1, 8, + 1, 8, 1, 9, 1, 9, 1, 9, 3, 9, 1195, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, + 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1210, + 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 1219, 8, + 11, 1, 11, 1, 11, 3, 11, 1223, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, + 3, 12, 1230, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 1, 12, 5, + 12, 1239, 8, 12, 10, 12, 12, 12, 1242, 9, 12, 1, 12, 3, 12, 1245, 8, 12, + 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 3, 13, 1252, 8, 13, 1, 13, 1, 13, 1, + 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, + 1, 14, 1, 14, 1, 14, 5, 14, 1270, 8, 14, 10, 14, 12, 14, 1273, 9, 14, 1, + 14, 1, 14, 3, 14, 1277, 8, 14, 1, 14, 1, 14, 3, 14, 1281, 8, 14, 1, 15, + 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 1288, 8, 15, 1, 16, 1, 16, 1, 16, 1, + 16, 1, 16, 1, 16, 1, 16, 3, 16, 1297, 8, 16, 3, 16, 1299, 8, 16, 1, 16, + 1, 16, 3, 16, 1303, 8, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, + 17, 1, 17, 1, 17, 3, 17, 1314, 8, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, + 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, + 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 3, 18, 1340, + 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 1349, 8, + 19, 1, 19, 3, 19, 1352, 8, 19, 1, 19, 3, 19, 1355, 8, 19, 1, 19, 3, 19, + 1358, 8, 19, 1, 19, 5, 19, 1361, 8, 19, 10, 19, 12, 19, 1364, 9, 19, 1, + 19, 1, 19, 1, 19, 3, 19, 1369, 8, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, + 1, 19, 1, 19, 3, 19, 1378, 8, 19, 1, 19, 3, 19, 1381, 8, 19, 1, 19, 3, + 19, 1384, 8, 19, 1, 19, 3, 19, 1387, 8, 19, 1, 19, 5, 19, 1390, 8, 19, + 10, 19, 12, 19, 1393, 9, 19, 3, 19, 1395, 8, 19, 1, 20, 1, 20, 1, 21, 1, + 21, 1, 21, 1, 21, 1, 21, 1, 21, 5, 21, 1405, 8, 21, 10, 21, 12, 21, 1408, + 9, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 3, 22, 1417, 8, + 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, + 5, 24, 1429, 8, 24, 10, 24, 12, 24, 1432, 9, 24, 1, 25, 1, 25, 1, 25, 1, + 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 4, 25, 1444, 8, 25, 11, 25, + 12, 25, 1445, 1, 25, 1, 25, 3, 25, 1450, 8, 25, 1, 26, 1, 26, 1, 26, 1, + 26, 1, 26, 3, 26, 1457, 8, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, + 3, 26, 1465, 8, 26, 1, 26, 3, 26, 1468, 8, 26, 1, 26, 3, 26, 1471, 8, 26, + 1, 26, 3, 26, 1474, 8, 26, 1, 26, 1, 26, 1, 26, 3, 26, 1479, 8, 26, 1, + 26, 3, 26, 1482, 8, 26, 1, 27, 1, 27, 3, 27, 1486, 8, 27, 1, 27, 1, 27, + 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 1496, 8, 27, 1, 27, 1, + 27, 1, 27, 1, 27, 1, 27, 1, 27, 3, 27, 1504, 8, 27, 1, 28, 1, 28, 3, 28, + 1508, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, + 29, 1518, 8, 29, 10, 29, 12, 29, 1521, 9, 29, 1, 29, 1, 29, 3, 29, 1525, + 8, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 1535, + 8, 29, 10, 29, 12, 29, 1538, 9, 29, 1, 29, 1, 29, 3, 29, 1542, 8, 29, 1, + 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 1552, 8, 29, + 10, 29, 12, 29, 1555, 9, 29, 1, 29, 1, 29, 3, 29, 1559, 8, 29, 3, 29, 1561, + 8, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 3, 31, 1570, 8, + 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, + 3, 33, 1582, 8, 33, 1, 33, 3, 33, 1585, 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, 3, 34, + 1600, 8, 34, 3, 34, 1602, 8, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, + 34, 1, 34, 1, 34, 3, 34, 1612, 8, 34, 3, 34, 1614, 8, 34, 1, 34, 1, 34, + 1, 34, 1, 34, 1, 34, 1, 34, 3, 34, 1622, 8, 34, 1, 35, 1, 35, 1, 35, 1, + 35, 3, 35, 1628, 8, 35, 3, 35, 1630, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 3, 35, 1637, 8, 35, 3, 35, 1639, 8, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 3, 35, 1648, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 3, 35, 1654, 8, 35, 3, 35, 1656, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 3, 35, 1666, 8, 35, 1, 35, 1, 35, 1, 35, 3, 35, + 1671, 8, 35, 3, 35, 1673, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 1, 35, 1, 35, 3, 35, 1684, 8, 35, 3, 35, 1686, 8, 35, 1, 35, + 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, + 35, 1699, 8, 35, 3, 35, 1701, 8, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1706, + 8, 35, 3, 35, 1708, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, + 35, 1, 35, 3, 35, 1718, 8, 35, 3, 35, 1720, 8, 35, 1, 35, 1, 35, 3, 35, + 1724, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1730, 8, 35, 1, 36, 1, + 36, 1, 36, 5, 36, 1735, 8, 36, 10, 36, 12, 36, 1738, 9, 36, 1, 37, 1, 37, + 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, + 37, 3, 37, 1753, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, + 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 1769, 8, 37, 1, + 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, + 3, 37, 1782, 8, 37, 3, 37, 1784, 8, 37, 1, 38, 1, 38, 1, 38, 5, 38, 1789, + 8, 38, 10, 38, 12, 38, 1792, 9, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, + 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 1803, 8, 39, 1, 40, 1, 40, 1, 40, 5, + 40, 1808, 8, 40, 10, 40, 12, 40, 1811, 9, 40, 1, 41, 1, 41, 1, 41, 1, 41, + 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, + 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, + 1, 41, 1, 41, 3, 41, 1840, 8, 41, 1, 41, 1, 41, 1, 41, 3, 41, 1845, 8, + 41, 1, 42, 1, 42, 1, 42, 5, 42, 1850, 8, 42, 10, 42, 12, 42, 1853, 9, 42, + 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 3, + 43, 1865, 8, 43, 1, 43, 1, 43, 1, 43, 3, 43, 1870, 8, 43, 1, 44, 1, 44, + 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, + 44, 1, 44, 1, 44, 1, 44, 3, 44, 1888, 8, 44, 1, 44, 1, 44, 3, 44, 1892, + 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, + 46, 1, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1908, 8, 46, 1, 47, 1, 47, 3, 47, + 1912, 8, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 3, 49, 1919, 8, 49, 1, + 49, 3, 49, 1922, 8, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, + 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1938, 8, 52, 1, + 52, 1, 52, 1, 52, 3, 52, 1943, 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1948, + 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1953, 8, 52, 1, 53, 1, 53, 1, 53, 3, + 53, 1958, 8, 53, 1, 53, 3, 53, 1961, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, + 3, 54, 1967, 8, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1972, 8, 54, 3, 54, 1974, + 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1981, 8, 54, 3, 54, 1983, + 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 1991, 8, 54, 1, + 54, 1, 54, 1, 54, 1, 54, 3, 54, 1997, 8, 54, 3, 54, 1999, 8, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2009, 8, 54, 1, + 54, 1, 54, 1, 54, 3, 54, 2014, 8, 54, 3, 54, 2016, 8, 54, 1, 54, 1, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2026, 8, 54, 3, 54, 2028, + 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, + 54, 3, 54, 2040, 8, 54, 1, 54, 1, 54, 1, 54, 3, 54, 2045, 8, 54, 3, 54, + 2047, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 3, + 54, 2057, 8, 54, 3, 54, 2059, 8, 54, 1, 54, 1, 54, 3, 54, 2063, 8, 54, + 1, 54, 1, 54, 3, 54, 2067, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, + 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 2083, + 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 2092, 8, + 55, 3, 55, 2094, 8, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, + 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 2108, 8, 56, 1, 57, 1, 57, 3, + 57, 2112, 8, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, + 1, 58, 1, 58, 5, 58, 2124, 8, 58, 10, 58, 12, 58, 2127, 9, 58, 1, 58, 1, + 58, 1, 58, 1, 58, 1, 58, 1, 58, 5, 58, 2135, 8, 58, 10, 58, 12, 58, 2138, + 9, 58, 1, 58, 1, 58, 3, 58, 2142, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, + 59, 1, 60, 1, 60, 3, 60, 2151, 8, 60, 1, 60, 3, 60, 2154, 8, 60, 1, 60, + 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 5, 61, 2165, 8, + 61, 10, 61, 12, 61, 2168, 9, 61, 1, 61, 1, 61, 3, 61, 2172, 8, 61, 1, 62, + 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, + 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, + 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, + 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 2214, 8, 62, + 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, + 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, + 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, + 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, + 3, 63, 2258, 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, 3, 64, 2285, 8, 64, 1, + 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, + 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, + 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, + 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, + 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, + 1, 66, 1, 66, 1, 66, 3, 66, 2343, 8, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, + 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, + 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, + 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, + 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, + 67, 1, 67, 1, 67, 1, 67, 1, 67, 3, 67, 2438, 8, 67, 1, 68, 1, 68, 1, 68, + 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 3, 70, 2451, 8, + 70, 1, 70, 1, 70, 1, 70, 1, 70, 4, 70, 2457, 8, 70, 11, 70, 12, 70, 2458, + 1, 70, 1, 70, 4, 70, 2463, 8, 70, 11, 70, 12, 70, 2464, 1, 70, 1, 70, 1, + 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 3, 70, 2477, 8, 70, + 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 3, 72, 2488, + 8, 72, 1, 73, 1, 73, 1, 74, 1, 74, 3, 74, 2494, 8, 74, 1, 74, 1, 74, 3, + 74, 2498, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2505, 8, 74, + 1, 74, 1, 74, 1, 74, 3, 74, 2510, 8, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2515, + 8, 74, 1, 74, 3, 74, 2518, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, + 74, 3, 74, 2526, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, + 2534, 8, 74, 1, 74, 3, 74, 2537, 8, 74, 1, 74, 1, 74, 3, 74, 2541, 8, 74, + 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2549, 8, 74, 1, 74, 1, + 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 2557, 8, 74, 1, 74, 1, 74, 3, 74, + 2561, 8, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 5, 74, 2568, 8, 74, 10, + 74, 12, 74, 2571, 9, 74, 3, 74, 2573, 8, 74, 1, 75, 1, 75, 1, 76, 1, 76, + 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 3, 77, 2584, 8, 77, 1, 77, 1, 77, 1, + 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2594, 8, 77, 1, 77, 1, 77, + 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2604, 8, 77, 1, 77, 1, + 77, 1, 77, 1, 77, 1, 77, 3, 77, 2611, 8, 77, 1, 77, 1, 77, 1, 77, 3, 77, + 2616, 8, 77, 1, 77, 3, 77, 2619, 8, 77, 1, 77, 3, 77, 2622, 8, 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, 2637, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 5, 77, + 2644, 8, 77, 10, 77, 12, 77, 2647, 9, 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, 2660, 8, 77, 1, 77, + 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2670, 8, 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, 2694, 8, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 2701, + 8, 77, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 5, 79, 2708, 8, 79, 10, 79, 12, + 79, 2711, 9, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, + 1, 80, 1, 80, 3, 80, 2723, 8, 80, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2729, + 8, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2734, 8, 81, 1, 81, 1, 81, 1, 81, 1, + 81, 3, 81, 2740, 8, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2753, 8, 81, 1, 81, 1, 81, 1, 81, 1, + 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2766, 8, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2773, 8, 81, 1, 81, 3, 81, 2776, + 8, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2782, 8, 81, 1, 81, 1, 81, 1, + 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2792, 8, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 5, 81, 2805, + 8, 81, 10, 81, 12, 81, 2808, 9, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, + 1, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2819, 8, 81, 1, 81, 1, 81, 1, 81, 1, + 81, 1, 81, 3, 81, 2826, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, + 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 5, 84, 2839, 8, 84, 10, 84, 12, 84, + 2842, 9, 84, 1, 85, 1, 85, 1, 85, 5, 85, 2847, 8, 85, 10, 85, 12, 85, 2850, + 9, 85, 1, 86, 1, 86, 1, 86, 5, 86, 2855, 8, 86, 10, 86, 12, 86, 2858, 9, + 86, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2864, 8, 87, 1, 87, 1, 87, 1, 87, + 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2875, 8, 87, 1, 87, 1, + 87, 1, 87, 1, 87, 1, 87, 3, 87, 2882, 8, 87, 1, 87, 3, 87, 2885, 8, 87, + 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2891, 8, 87, 1, 87, 1, 87, 1, 87, 1, + 87, 1, 87, 1, 87, 3, 87, 2899, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, + 2905, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, + 87, 1, 87, 3, 87, 2917, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, + 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2932, 8, 87, 1, + 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, + 2944, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, + 87, 1, 87, 3, 87, 2956, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, + 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2971, 8, 87, 1, + 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, + 2983, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2991, 8, + 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 2997, 8, 87, 1, 87, 1, 87, 1, 87, + 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 3009, 8, 87, 1, + 87, 1, 87, 1, 87, 3, 87, 3014, 8, 87, 1, 88, 1, 88, 1, 88, 1, 88, 3, 88, + 3020, 8, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, + 88, 3, 88, 3031, 8, 88, 1, 88, 1, 88, 1, 88, 5, 88, 3036, 8, 88, 10, 88, + 12, 88, 3039, 9, 88, 1, 88, 3, 88, 3042, 8, 88, 3, 88, 3044, 8, 88, 1, + 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, + 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 5, 89, 3075, 8, 89, + 10, 89, 12, 89, 3078, 9, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, + 1, 89, 1, 89, 5, 89, 3088, 8, 89, 10, 89, 12, 89, 3091, 9, 89, 1, 89, 1, + 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, + 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, + 89, 1, 89, 3, 89, 3117, 8, 89, 1, 90, 1, 90, 1, 90, 3, 90, 3122, 8, 90, + 1, 90, 1, 90, 1, 90, 3, 90, 3127, 8, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, + 91, 5, 91, 3134, 8, 91, 10, 91, 12, 91, 3137, 9, 91, 1, 92, 1, 92, 1, 92, + 1, 92, 3, 92, 3143, 8, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, + 92, 1, 92, 1, 92, 1, 92, 3, 92, 3155, 8, 92, 1, 92, 1, 92, 1, 92, 1, 92, + 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 3, 92, 3166, 8, 92, 1, 92, 1, 92, 1, + 92, 1, 92, 3, 92, 3172, 8, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, + 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, + 93, 1, 93, 3, 93, 3192, 8, 93, 1, 93, 1, 93, 3, 93, 3196, 8, 93, 1, 93, + 3, 93, 3199, 8, 93, 1, 93, 1, 93, 3, 93, 3203, 8, 93, 1, 94, 1, 94, 1, + 94, 1, 94, 1, 94, 1, 95, 1, 95, 3, 95, 3212, 8, 95, 1, 95, 1, 95, 3, 95, + 3216, 8, 95, 1, 95, 1, 95, 1, 95, 3, 95, 3221, 8, 95, 1, 95, 1, 95, 3, + 95, 3225, 8, 95, 1, 95, 1, 95, 3, 95, 3229, 8, 95, 1, 95, 1, 95, 3, 95, + 3233, 8, 95, 1, 95, 1, 95, 1, 95, 3, 95, 3238, 8, 95, 1, 95, 1, 95, 3, + 95, 3242, 8, 95, 1, 95, 1, 95, 3, 95, 3246, 8, 95, 1, 95, 1, 95, 1, 95, + 1, 95, 1, 95, 1, 95, 3, 95, 3254, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, + 95, 1, 95, 3, 95, 3262, 8, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, + 3, 95, 3270, 8, 95, 1, 96, 1, 96, 1, 96, 3, 96, 3275, 8, 96, 1, 96, 1, + 96, 1, 96, 3, 96, 3280, 8, 96, 1, 96, 3, 96, 3283, 8, 96, 1, 96, 1, 96, + 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, + 96, 3, 96, 3298, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, + 1, 96, 1, 96, 3, 96, 3309, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, + 96, 1, 96, 3, 96, 3318, 8, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 3, 96, + 3325, 8, 96, 1, 96, 1, 96, 1, 96, 3, 96, 3330, 8, 96, 3, 96, 3332, 8, 96, + 1, 97, 1, 97, 1, 97, 3, 97, 3337, 8, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3342, + 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3352, + 8, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3357, 8, 97, 1, 97, 1, 97, 1, 97, 1, + 97, 1, 97, 1, 97, 1, 97, 3, 97, 3366, 8, 97, 1, 97, 1, 97, 1, 97, 3, 97, + 3371, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3380, + 8, 97, 1, 97, 1, 97, 1, 97, 3, 97, 3385, 8, 97, 1, 97, 1, 97, 1, 97, 1, + 97, 1, 97, 3, 97, 3392, 8, 97, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3398, + 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, + 98, 3409, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3416, 8, 98, + 1, 98, 1, 98, 1, 98, 3, 98, 3421, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, + 98, 3427, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, + 1, 98, 1, 98, 5, 98, 3439, 8, 98, 10, 98, 12, 98, 3442, 9, 98, 1, 98, 1, + 98, 1, 98, 3, 98, 3447, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3453, + 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, + 98, 3, 98, 3465, 8, 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, 3480, 8, 98, 1, 98, 1, + 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3492, + 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, + 98, 3, 98, 3504, 8, 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, 3519, 8, 98, 1, 98, 1, + 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3531, + 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3539, 8, 98, 1, + 98, 1, 98, 1, 98, 1, 98, 3, 98, 3545, 8, 98, 1, 98, 1, 98, 1, 98, 1, 98, + 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3557, 8, 98, 1, 98, 1, + 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3566, 8, 98, 1, 98, 1, 98, + 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 3, 98, 3575, 8, 98, 1, 98, 1, 98, 1, + 98, 3, 98, 3580, 8, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, + 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 5, 101, 3596, + 8, 101, 10, 101, 12, 101, 3599, 9, 101, 1, 101, 1, 101, 1, 102, 1, 102, + 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, + 3613, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 3618, 8, 103, 1, 103, 3, + 103, 3621, 8, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, + 3629, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 3634, 8, 103, 3, 103, 3636, + 8, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 5, 103, 3643, 8, 103, 10, + 103, 12, 103, 3646, 9, 103, 3, 103, 3648, 8, 103, 3, 103, 3650, 8, 103, + 1, 104, 1, 104, 1, 104, 3, 104, 3655, 8, 104, 1, 104, 1, 104, 1, 104, 1, + 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 3665, 8, 104, 1, 104, 1, 104, + 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 3674, 8, 104, 1, 104, 1, + 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 3683, 8, 104, 1, 104, + 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 3, 104, 3691, 8, 104, 1, 104, 1, + 104, 1, 104, 3, 104, 3696, 8, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, + 3, 105, 3703, 8, 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, 3716, 8, 105, 1, 105, 1, 105, + 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, + 3728, 8, 105, 1, 105, 1, 105, 1, 105, 1, 105, 3, 105, 3734, 8, 105, 1, + 106, 1, 106, 1, 106, 3, 106, 3739, 8, 106, 1, 106, 1, 106, 1, 106, 1, 106, + 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 3749, 8, 106, 1, 106, 1, 106, 1, + 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 3759, 8, 106, 1, 106, + 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 3766, 8, 106, 1, 106, 1, 106, 1, + 106, 3, 106, 3771, 8, 106, 1, 106, 3, 106, 3774, 8, 106, 1, 106, 3, 106, + 3777, 8, 106, 1, 106, 1, 106, 1, 106, 3, 106, 3782, 8, 106, 1, 106, 1, + 106, 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 3790, 8, 106, 1, 106, 1, 106, + 1, 106, 1, 106, 1, 106, 1, 106, 3, 106, 3798, 8, 106, 1, 106, 1, 106, 1, + 106, 1, 106, 1, 106, 5, 106, 3805, 8, 106, 10, 106, 12, 106, 3808, 9, 106, + 1, 106, 1, 106, 1, 106, 3, 106, 3813, 8, 106, 1, 106, 1, 106, 1, 106, 1, + 106, 1, 106, 3, 106, 3820, 8, 106, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, + 3, 108, 3827, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, + 108, 1, 108, 3, 108, 3837, 8, 108, 1, 108, 1, 108, 3, 108, 3841, 8, 108, + 1, 108, 1, 108, 3, 108, 3845, 8, 108, 1, 108, 3, 108, 3848, 8, 108, 1, + 108, 3, 108, 3851, 8, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3856, 8, 108, + 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3865, 8, + 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 3871, 8, 108, 1, 109, 1, 109, + 3, 109, 3875, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, + 109, 3, 109, 3884, 8, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3889, 8, 109, + 1, 109, 1, 109, 1, 109, 3, 109, 3894, 8, 109, 1, 109, 1, 109, 1, 109, 3, + 109, 3899, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, + 3, 109, 3908, 8, 109, 3, 109, 3910, 8, 109, 1, 109, 1, 109, 1, 109, 3, + 109, 3915, 8, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3920, 8, 109, 1, 109, + 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3929, 8, 109, 3, + 109, 3931, 8, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3936, 8, 109, 1, 109, + 1, 109, 1, 109, 3, 109, 3941, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, + 109, 1, 109, 3, 109, 3949, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, + 1, 109, 3, 109, 3957, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, + 109, 3, 109, 3965, 8, 109, 1, 109, 1, 109, 1, 109, 3, 109, 3970, 8, 109, + 1, 109, 1, 109, 1, 109, 3, 109, 3975, 8, 109, 1, 109, 1, 109, 3, 109, 3979, + 8, 109, 1, 109, 1, 109, 3, 109, 3983, 8, 109, 1, 109, 1, 109, 1, 109, 1, + 109, 1, 109, 5, 109, 3990, 8, 109, 10, 109, 12, 109, 3993, 9, 109, 1, 109, + 1, 109, 3, 109, 3997, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, + 109, 3, 109, 4005, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 4011, + 8, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, + 3, 110, 4021, 8, 110, 1, 111, 1, 111, 3, 111, 4025, 8, 111, 1, 111, 1, + 111, 3, 111, 4029, 8, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, + 4036, 8, 111, 1, 111, 3, 111, 4039, 8, 111, 1, 111, 1, 111, 1, 111, 3, + 111, 4044, 8, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4049, 8, 111, 1, 111, + 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4058, 8, 111, 3, + 111, 4060, 8, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4065, 8, 111, 1, 111, + 1, 111, 1, 111, 3, 111, 4070, 8, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, + 111, 1, 111, 1, 111, 3, 111, 4079, 8, 111, 3, 111, 4081, 8, 111, 1, 111, + 1, 111, 1, 111, 3, 111, 4086, 8, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4091, + 8, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4099, 8, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4107, 8, 111, + 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4115, 8, 111, 1, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4122, 8, 111, 1, 111, 1, 111, + 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4130, 8, 111, 1, 111, 1, 111, 3, + 111, 4134, 8, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 5, 111, 4141, + 8, 111, 10, 111, 12, 111, 4144, 9, 111, 1, 111, 1, 111, 3, 111, 4148, 8, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4156, 8, 111, + 1, 111, 1, 111, 1, 111, 1, 111, 3, 111, 4162, 8, 111, 1, 112, 1, 112, 1, + 113, 1, 113, 3, 113, 4168, 8, 113, 1, 113, 1, 113, 3, 113, 4172, 8, 113, + 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4179, 8, 113, 1, 113, 3, + 113, 4182, 8, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4187, 8, 113, 1, 113, + 1, 113, 1, 113, 3, 113, 4192, 8, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4197, + 8, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4202, 8, 113, 1, 113, 1, 113, 1, + 113, 3, 113, 4207, 8, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4212, 8, 113, + 1, 113, 1, 113, 1, 113, 3, 113, 4217, 8, 113, 1, 113, 1, 113, 1, 113, 3, + 113, 4222, 8, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4227, 8, 113, 1, 113, + 1, 113, 1, 113, 3, 113, 4232, 8, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4237, + 8, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4242, 8, 113, 1, 113, 1, 113, 1, + 113, 3, 113, 4247, 8, 113, 1, 113, 1, 113, 3, 113, 4251, 8, 113, 1, 113, + 1, 113, 3, 113, 4255, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, + 113, 3, 113, 4263, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, + 3, 113, 4271, 8, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 4277, 8, + 113, 1, 114, 1, 114, 3, 114, 4281, 8, 114, 1, 114, 1, 114, 3, 114, 4285, + 8, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 4292, 8, 114, 1, + 114, 1, 114, 1, 114, 3, 114, 4297, 8, 114, 1, 114, 3, 114, 4300, 8, 114, + 1, 114, 1, 114, 3, 114, 4304, 8, 114, 1, 114, 1, 114, 3, 114, 4308, 8, + 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 5, 114, 4315, 8, 114, 10, + 114, 12, 114, 4318, 9, 114, 1, 114, 1, 114, 3, 114, 4322, 8, 114, 1, 114, + 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 3, 114, 4330, 8, 114, 1, 114, 1, + 114, 1, 114, 1, 114, 3, 114, 4336, 8, 114, 1, 115, 1, 115, 1, 116, 1, 116, + 1, 116, 3, 116, 4343, 8, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, + 116, 1, 116, 1, 116, 3, 116, 4353, 8, 116, 1, 116, 1, 116, 3, 116, 4357, + 8, 116, 1, 116, 1, 116, 3, 116, 4361, 8, 116, 1, 116, 3, 116, 4364, 8, + 116, 1, 116, 3, 116, 4367, 8, 116, 1, 116, 1, 116, 1, 116, 3, 116, 4372, + 8, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, + 4381, 8, 116, 1, 116, 1, 116, 1, 116, 1, 116, 3, 116, 4387, 8, 116, 1, + 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, + 117, 5, 117, 4399, 8, 117, 10, 117, 12, 117, 4402, 9, 117, 3, 117, 4404, + 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 4410, 8, 118, 1, 118, 1, + 118, 1, 118, 1, 118, 1, 118, 3, 118, 4417, 8, 118, 1, 118, 1, 118, 1, 118, + 3, 118, 4422, 8, 118, 1, 118, 3, 118, 4425, 8, 118, 1, 118, 1, 118, 1, + 118, 1, 118, 3, 118, 4431, 8, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, + 3, 118, 4438, 8, 118, 1, 119, 1, 119, 1, 119, 3, 119, 4443, 8, 119, 1, + 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 5, 119, 4452, 8, 119, + 10, 119, 12, 119, 4455, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 4460, 8, + 119, 1, 119, 1, 119, 1, 119, 3, 119, 4465, 8, 119, 1, 119, 1, 119, 1, 119, + 1, 119, 1, 119, 1, 119, 1, 119, 5, 119, 4474, 8, 119, 10, 119, 12, 119, + 4477, 9, 119, 1, 119, 1, 119, 1, 119, 3, 119, 4482, 8, 119, 1, 119, 1, + 119, 1, 119, 3, 119, 4487, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, + 1, 119, 1, 119, 5, 119, 4496, 8, 119, 10, 119, 12, 119, 4499, 9, 119, 3, + 119, 4501, 8, 119, 1, 119, 3, 119, 4504, 8, 119, 1, 119, 1, 119, 1, 119, + 3, 119, 4509, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, + 119, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 4522, 8, 119, 1, 119, 1, 119, + 1, 119, 1, 119, 3, 119, 4528, 8, 119, 1, 120, 1, 120, 1, 120, 3, 120, 4533, + 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, + 3, 120, 4543, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, + 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 4556, 8, 120, 1, 120, 1, 120, + 1, 120, 3, 120, 4561, 8, 120, 1, 120, 3, 120, 4564, 8, 120, 1, 120, 1, + 120, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 4572, 8, 120, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 3, 120, 4579, 8, 120, 1, 120, 1, 120, 1, 120, 3, + 120, 4584, 8, 120, 1, 120, 3, 120, 4587, 8, 120, 1, 120, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 3, 120, 4595, 8, 120, 1, 120, 3, 120, 4598, 8, + 120, 3, 120, 4600, 8, 120, 1, 121, 1, 121, 3, 121, 4604, 8, 121, 1, 121, + 1, 121, 3, 121, 4608, 8, 121, 1, 121, 1, 121, 1, 121, 3, 121, 4613, 8, + 121, 1, 121, 3, 121, 4616, 8, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, + 1, 121, 3, 121, 4624, 8, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1, + 121, 3, 121, 4632, 8, 121, 1, 121, 3, 121, 4635, 8, 121, 1, 121, 1, 121, + 3, 121, 4639, 8, 121, 1, 121, 1, 121, 3, 121, 4643, 8, 121, 1, 121, 1, + 121, 1, 121, 1, 121, 1, 121, 3, 121, 4650, 8, 121, 1, 121, 1, 121, 1, 121, + 1, 121, 1, 121, 1, 121, 3, 121, 4658, 8, 121, 1, 121, 1, 121, 3, 121, 4662, + 8, 121, 1, 121, 1, 121, 1, 121, 1, 121, 3, 121, 4668, 8, 121, 1, 122, 1, + 122, 1, 122, 3, 122, 4673, 8, 122, 1, 122, 1, 122, 1, 122, 3, 122, 4678, + 8, 122, 1, 122, 3, 122, 4681, 8, 122, 1, 122, 1, 122, 1, 122, 3, 122, 4686, + 8, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, + 1, 122, 1, 122, 1, 122, 3, 122, 4699, 8, 122, 1, 122, 1, 122, 1, 122, 1, + 122, 3, 122, 4705, 8, 122, 1, 123, 1, 123, 1, 123, 3, 123, 4710, 8, 123, + 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, + 4720, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, + 123, 3, 123, 4730, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, 4736, + 8, 123, 1, 123, 1, 123, 1, 123, 3, 123, 4741, 8, 123, 1, 123, 1, 123, 1, + 123, 1, 123, 1, 123, 1, 123, 3, 123, 4749, 8, 123, 1, 123, 1, 123, 1, 123, + 1, 123, 1, 123, 1, 123, 3, 123, 4757, 8, 123, 1, 123, 1, 123, 1, 123, 3, + 123, 4762, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, 123, + 4770, 8, 123, 1, 123, 1, 123, 1, 123, 3, 123, 4775, 8, 123, 1, 123, 1, + 123, 1, 123, 3, 123, 4780, 8, 123, 1, 123, 1, 123, 1, 123, 3, 123, 4785, + 8, 123, 1, 123, 3, 123, 4788, 8, 123, 1, 123, 3, 123, 4791, 8, 123, 1, + 123, 1, 123, 1, 123, 3, 123, 4796, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, + 1, 123, 1, 123, 3, 123, 4804, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, + 123, 1, 123, 3, 123, 4812, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, + 1, 123, 1, 123, 1, 123, 3, 123, 4822, 8, 123, 1, 123, 1, 123, 1, 123, 3, + 123, 4827, 8, 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, 4841, 8, 123, 1, 123, 1, + 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 3, + 123, 4853, 8, 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, 1, 123, 1, 123, 1, 123, + 1, 123, 1, 123, 3, 123, 4873, 8, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, + 123, 1, 123, 1, 123, 3, 123, 4882, 8, 123, 1, 124, 1, 124, 1, 124, 1, 124, + 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 3, 124, 4894, 8, 124, 1, + 124, 1, 124, 3, 124, 4898, 8, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, + 1, 124, 3, 124, 4906, 8, 124, 1, 125, 1, 125, 3, 125, 4910, 8, 125, 1, + 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 4928, 8, 125, + 3, 125, 4930, 8, 125, 1, 125, 3, 125, 4933, 8, 125, 1, 125, 3, 125, 4936, + 8, 125, 1, 125, 3, 125, 4939, 8, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 4951, 8, 125, 3, 125, + 4953, 8, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 3, 125, 4963, 8, 125, 1, 125, 3, 125, 4966, 8, 125, 1, 125, 1, 125, + 1, 125, 1, 125, 1, 125, 3, 125, 4973, 8, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 4983, 8, 125, 1, 125, 1, 125, + 3, 125, 4987, 8, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 4994, + 8, 125, 1, 125, 1, 125, 3, 125, 4998, 8, 125, 1, 125, 1, 125, 1, 125, 3, + 125, 5003, 8, 125, 1, 125, 3, 125, 5006, 8, 125, 1, 125, 1, 125, 1, 125, + 3, 125, 5011, 8, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 5017, 8, + 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, 125, 5023, 8, 125, 1, 125, 1, 125, + 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, + 1, 125, 1, 125, 1, 125, 3, 125, 5039, 8, 125, 1, 125, 3, 125, 5042, 8, + 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, + 125, 1, 125, 1, 125, 5, 125, 5055, 8, 125, 10, 125, 12, 125, 5058, 9, 125, + 1, 125, 1, 125, 1, 125, 1, 125, 5, 125, 5064, 8, 125, 10, 125, 12, 125, + 5067, 9, 125, 1, 125, 1, 125, 3, 125, 5071, 8, 125, 1, 125, 3, 125, 5074, + 8, 125, 1, 126, 3, 126, 5077, 8, 126, 1, 126, 1, 126, 3, 126, 5081, 8, + 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 5088, 8, 126, 1, 126, + 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, 5096, 8, 126, 3, 126, 5098, + 8, 126, 1, 126, 3, 126, 5101, 8, 126, 1, 127, 3, 127, 5104, 8, 127, 1, + 127, 1, 127, 3, 127, 5108, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, + 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, + 3, 127, 5124, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, + 127, 1, 127, 1, 127, 3, 127, 5135, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, + 1, 127, 1, 127, 3, 127, 5143, 8, 127, 1, 128, 1, 128, 3, 128, 5147, 8, + 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, + 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 3, 128, 5164, 8, 128, + 1, 128, 3, 128, 5167, 8, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, + 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, + 129, 1, 129, 3, 129, 5185, 8, 129, 1, 129, 1, 129, 3, 129, 5189, 8, 129, + 1, 129, 3, 129, 5192, 8, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, + 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 3, 129, 5205, 8, 129, 1, 129, + 1, 129, 3, 129, 5209, 8, 129, 3, 129, 5211, 8, 129, 1, 130, 1, 130, 1, + 130, 1, 130, 1, 130, 1, 130, 1, 130, 5, 130, 5220, 8, 130, 10, 130, 12, + 130, 5223, 9, 130, 3, 130, 5225, 8, 130, 1, 130, 1, 130, 1, 130, 1, 130, + 1, 130, 1, 130, 1, 130, 5, 130, 5234, 8, 130, 10, 130, 12, 130, 5237, 9, + 130, 3, 130, 5239, 8, 130, 3, 130, 5241, 8, 130, 1, 131, 1, 131, 1, 131, + 1, 131, 3, 131, 5247, 8, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, + 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 5260, 8, 132, 1, 132, + 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, + 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 3, 132, 5279, 8, + 132, 1, 132, 3, 132, 5282, 8, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, + 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, + 1, 132, 1, 132, 1, 132, 5, 132, 5301, 8, 132, 10, 132, 12, 132, 5304, 9, + 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 5, 132, 5313, + 8, 132, 10, 132, 12, 132, 5316, 9, 132, 3, 132, 5318, 8, 132, 1, 133, 1, + 133, 1, 133, 5, 133, 5323, 8, 133, 10, 133, 12, 133, 5326, 9, 133, 1, 134, + 3, 134, 5329, 8, 134, 1, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, + 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 5343, 8, 135, 1, 135, + 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 5350, 8, 135, 1, 135, 1, 135, 3, + 135, 5354, 8, 135, 1, 135, 3, 135, 5357, 8, 135, 1, 135, 1, 135, 1, 135, + 1, 135, 3, 135, 5363, 8, 135, 1, 136, 3, 136, 5366, 8, 136, 1, 136, 1, + 136, 1, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, + 138, 1, 139, 1, 139, 1, 139, 3, 139, 5382, 8, 139, 1, 139, 1, 139, 1, 139, + 1, 139, 1, 139, 1, 139, 3, 139, 5390, 8, 139, 1, 139, 1, 139, 1, 139, 1, + 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 5403, + 8, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 5410, 8, 139, 1, + 139, 1, 139, 1, 139, 3, 139, 5415, 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, + 5420, 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, 5425, 8, 139, 1, 139, 1, + 139, 1, 139, 3, 139, 5430, 8, 139, 1, 139, 3, 139, 5433, 8, 139, 1, 139, + 3, 139, 5436, 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, 5441, 8, 139, 1, + 139, 1, 139, 1, 139, 3, 139, 5446, 8, 139, 1, 139, 3, 139, 5449, 8, 139, + 1, 139, 3, 139, 5452, 8, 139, 1, 139, 3, 139, 5455, 8, 139, 1, 139, 3, + 139, 5458, 8, 139, 1, 139, 3, 139, 5461, 8, 139, 1, 139, 3, 139, 5464, + 8, 139, 1, 139, 1, 139, 1, 139, 3, 139, 5469, 8, 139, 1, 139, 1, 139, 1, + 139, 1, 139, 1, 139, 1, 139, 3, 139, 5477, 8, 139, 1, 139, 1, 139, 1, 139, + 1, 139, 1, 139, 1, 139, 3, 139, 5485, 8, 139, 1, 139, 1, 139, 1, 139, 1, + 139, 1, 139, 1, 139, 1, 139, 1, 139, 3, 139, 5495, 8, 139, 1, 139, 1, 139, + 1, 139, 1, 139, 1, 139, 3, 139, 5502, 8, 139, 1, 140, 1, 140, 1, 140, 3, + 140, 5507, 8, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 3, 141, + 5515, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 3, 141, 5525, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 3, 141, 5534, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 5555, 8, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 5563, 8, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 3, 141, 5571, 8, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 3, 141, 5585, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 3, 141, 5597, 8, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 5617, 8, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 3, 141, 5631, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, + 5645, 8, 141, 1, 141, 3, 141, 5648, 8, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 3, 141, 5655, 8, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, + 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 3, 141, 5667, 8, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 3, 141, 5680, 8, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 3, 143, + 5687, 8, 143, 1, 143, 1, 143, 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, 5, 144, 5704, + 8, 144, 10, 144, 12, 144, 5707, 9, 144, 1, 144, 3, 144, 5710, 8, 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, 5725, 8, 144, 1, 144, 1, 144, 1, 144, + 1, 144, 3, 144, 5731, 8, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, + 144, 5738, 8, 144, 1, 144, 1, 144, 1, 144, 1, 144, 3, 144, 5744, 8, 144, + 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, + 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, + 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, + 5772, 8, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 3, 145, 5780, + 8, 145, 1, 146, 3, 146, 5783, 8, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 3, 146, 5791, 8, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, + 1, 146, 5, 146, 5799, 8, 146, 10, 146, 12, 146, 5802, 9, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, + 146, 1, 146, 1, 146, 5, 146, 5817, 8, 146, 10, 146, 12, 146, 5820, 9, 146, + 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, + 5, 146, 5831, 8, 146, 10, 146, 12, 146, 5834, 9, 146, 1, 146, 3, 146, 5837, + 8, 146, 1, 146, 1, 146, 1, 146, 1, 146, 1, 146, 3, 146, 5844, 8, 146, 1, + 146, 1, 146, 1, 146, 1, 146, 3, 146, 5850, 8, 146, 1, 147, 3, 147, 5853, + 8, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, + 3, 147, 5863, 8, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 3, + 147, 5871, 8, 147, 1, 147, 3, 147, 5874, 8, 147, 1, 147, 3, 147, 5877, + 8, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, + 1, 147, 3, 147, 5888, 8, 147, 1, 148, 3, 148, 5891, 8, 148, 1, 148, 1, + 148, 1, 148, 3, 148, 5896, 8, 148, 3, 148, 5898, 8, 148, 1, 148, 3, 148, + 5901, 8, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, + 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 148, 1, + 148, 1, 148, 1, 148, 5, 148, 5922, 8, 148, 10, 148, 12, 148, 5925, 9, 148, + 3, 148, 5927, 8, 148, 1, 149, 1, 149, 3, 149, 5931, 8, 149, 1, 149, 3, + 149, 5934, 8, 149, 1, 149, 3, 149, 5937, 8, 149, 1, 149, 1, 149, 1, 149, + 1, 149, 3, 149, 5943, 8, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, + 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 5958, + 8, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 5965, 8, 149, 1, + 150, 1, 150, 1, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, + 151, 1, 151, 1, 151, 5, 151, 5979, 8, 151, 10, 151, 12, 151, 5982, 9, 151, + 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 5, 152, 5989, 8, 152, 10, 152, + 12, 152, 5992, 9, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, + 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, + 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, + 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, + 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 3, 153, + 6035, 8, 153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, + 154, 1, 154, 1, 154, 1, 154, 1, 154, 3, 154, 6049, 8, 154, 1, 154, 1, 154, + 1, 154, 3, 154, 6054, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, + 154, 3, 154, 6062, 8, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, + 3, 154, 6070, 8, 154, 1, 154, 1, 154, 1, 154, 3, 154, 6075, 8, 154, 1, + 154, 3, 154, 6078, 8, 154, 1, 155, 1, 155, 3, 155, 6082, 8, 155, 1, 155, + 1, 155, 3, 155, 6086, 8, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, + 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, + 155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 3, 156, 6108, 8, 156, 1, 157, + 1, 157, 1, 158, 1, 158, 3, 158, 6114, 8, 158, 1, 158, 1, 158, 1, 158, 3, + 158, 6119, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 3, 158, 6131, 8, 158, 1, 158, 1, 158, 1, 158, 1, + 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 6144, + 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 6150, 8, 158, 1, 158, 1, + 158, 3, 158, 6154, 8, 158, 1, 158, 1, 158, 1, 158, 3, 158, 6159, 8, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 6174, 8, 158, 1, 158, 1, 158, 1, + 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, + 158, 6187, 8, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 6193, 8, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, + 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 3, 158, 6218, 8, 158, 1, 158, 1, + 158, 1, 158, 1, 158, 3, 158, 6224, 8, 158, 3, 158, 6226, 8, 158, 1, 159, + 1, 159, 3, 159, 6230, 8, 159, 1, 159, 1, 159, 3, 159, 6234, 8, 159, 1, + 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, + 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 6250, 8, 159, 1, 159, 1, 159, + 3, 159, 6254, 8, 159, 1, 159, 1, 159, 3, 159, 6258, 8, 159, 1, 159, 1, + 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 6266, 8, 159, 1, 159, 3, 159, + 6269, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, 3, 159, 6275, 8, 159, 1, + 160, 1, 160, 1, 160, 3, 160, 6280, 8, 160, 1, 160, 1, 160, 3, 160, 6284, + 8, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, + 1, 160, 3, 160, 6295, 8, 160, 3, 160, 6297, 8, 160, 1, 161, 1, 161, 3, + 161, 6301, 8, 161, 1, 161, 3, 161, 6304, 8, 161, 1, 161, 1, 161, 3, 161, + 6308, 8, 161, 1, 161, 1, 161, 3, 161, 6312, 8, 161, 1, 161, 1, 161, 1, + 161, 3, 161, 6317, 8, 161, 1, 161, 1, 161, 1, 161, 3, 161, 6322, 8, 161, + 1, 161, 3, 161, 6325, 8, 161, 1, 161, 3, 161, 6328, 8, 161, 1, 161, 3, + 161, 6331, 8, 161, 1, 162, 1, 162, 3, 162, 6335, 8, 162, 1, 162, 1, 162, + 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 6344, 8, 162, 1, 162, 1, + 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1, 163, 1, 163, 1, 163, 1, + 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 3, + 163, 6365, 8, 163, 1, 163, 1, 163, 3, 163, 6369, 8, 163, 1, 164, 1, 164, + 1, 165, 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, + 1, 167, 1, 168, 1, 168, 3, 168, 6385, 8, 168, 1, 168, 3, 168, 6388, 8, + 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, + 168, 1, 168, 5, 168, 6400, 8, 168, 10, 168, 12, 168, 6403, 9, 168, 3, 168, + 6405, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 6411, 8, 168, 1, + 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, + 168, 3, 168, 6423, 8, 168, 3, 168, 6425, 8, 168, 1, 168, 3, 168, 6428, + 8, 168, 1, 168, 3, 168, 6431, 8, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, + 168, 1, 168, 1, 168, 1, 168, 1, 168, 5, 168, 6442, 8, 168, 10, 168, 12, + 168, 6445, 9, 168, 1, 168, 1, 168, 3, 168, 6449, 8, 168, 1, 168, 1, 168, + 1, 168, 1, 168, 1, 168, 1, 168, 5, 168, 6457, 8, 168, 10, 168, 12, 168, + 6460, 9, 168, 1, 168, 1, 168, 3, 168, 6464, 8, 168, 1, 168, 1, 168, 1, + 168, 3, 168, 6469, 8, 168, 1, 168, 3, 168, 6472, 8, 168, 1, 168, 1, 168, + 1, 168, 3, 168, 6477, 8, 168, 1, 168, 1, 168, 1, 168, 3, 168, 6482, 8, + 168, 1, 168, 1, 168, 1, 168, 1, 169, 1, 169, 3, 169, 6489, 8, 169, 1, 169, + 1, 169, 1, 169, 3, 169, 6494, 8, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, + 169, 3, 169, 6501, 8, 169, 1, 169, 3, 169, 6504, 8, 169, 1, 169, 3, 169, + 6507, 8, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 6515, + 8, 169, 1, 169, 1, 169, 1, 169, 3, 169, 6520, 8, 169, 1, 169, 3, 169, 6523, + 8, 169, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 6529, 8, 169, 1, 169, 3, + 169, 6532, 8, 169, 1, 169, 3, 169, 6535, 8, 169, 1, 169, 3, 169, 6538, + 8, 169, 1, 169, 3, 169, 6541, 8, 169, 1, 169, 1, 169, 3, 169, 6545, 8, + 169, 1, 169, 1, 169, 1, 169, 3, 169, 6550, 8, 169, 1, 169, 1, 169, 1, 169, + 1, 169, 1, 169, 3, 169, 6557, 8, 169, 1, 169, 3, 169, 6560, 8, 169, 1, + 169, 3, 169, 6563, 8, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, + 1, 169, 1, 169, 3, 169, 6573, 8, 169, 1, 169, 3, 169, 6576, 8, 169, 1, + 169, 3, 169, 6579, 8, 169, 1, 169, 3, 169, 6582, 8, 169, 1, 169, 1, 169, + 3, 169, 6586, 8, 169, 1, 169, 1, 169, 1, 169, 3, 169, 6591, 8, 169, 1, + 169, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 6598, 8, 169, 1, 169, 3, 169, + 6601, 8, 169, 1, 169, 3, 169, 6604, 8, 169, 1, 169, 1, 169, 1, 169, 1, + 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 3, 169, 6616, 8, 169, + 1, 169, 3, 169, 6619, 8, 169, 1, 169, 3, 169, 6622, 8, 169, 1, 169, 3, + 169, 6625, 8, 169, 1, 169, 3, 169, 6628, 8, 169, 3, 169, 6630, 8, 169, + 1, 170, 1, 170, 1, 170, 1, 170, 1, 170, 3, 170, 6637, 8, 170, 1, 170, 3, + 170, 6640, 8, 170, 1, 171, 1, 171, 1, 171, 5, 171, 6645, 8, 171, 10, 171, + 12, 171, 6648, 9, 171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, + 1, 173, 1, 173, 3, 173, 6658, 8, 173, 1, 174, 1, 174, 1, 174, 1, 174, 3, + 174, 6664, 8, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 5, 174, + 6672, 8, 174, 10, 174, 12, 174, 6675, 9, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 5, 174, 6682, 8, 174, 10, 174, 12, 174, 6685, 9, 174, 3, 174, + 6687, 8, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 5, 174, 6694, 8, + 174, 10, 174, 12, 174, 6697, 9, 174, 3, 174, 6699, 8, 174, 1, 174, 1, 174, + 1, 174, 1, 174, 1, 174, 5, 174, 6706, 8, 174, 10, 174, 12, 174, 6709, 9, + 174, 3, 174, 6711, 8, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 5, 174, + 6718, 8, 174, 10, 174, 12, 174, 6721, 9, 174, 1, 174, 1, 174, 1, 174, 3, + 174, 6726, 8, 174, 1, 174, 1, 174, 1, 174, 3, 174, 6731, 8, 174, 1, 174, + 1, 174, 1, 174, 1, 174, 3, 174, 6737, 8, 174, 1, 174, 1, 174, 1, 174, 1, + 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 1, 174, 3, 174, 6749, 8, 174, + 1, 175, 1, 175, 1, 176, 1, 176, 3, 176, 6755, 8, 176, 1, 176, 1, 176, 1, + 176, 3, 176, 6760, 8, 176, 1, 176, 1, 176, 1, 176, 1, 176, 3, 176, 6766, + 8, 176, 1, 176, 5, 176, 6769, 8, 176, 10, 176, 12, 176, 6772, 9, 176, 1, + 176, 3, 176, 6775, 8, 176, 1, 177, 1, 177, 1, 177, 1, 178, 1, 178, 1, 178, + 1, 179, 1, 179, 3, 179, 6785, 8, 179, 1, 180, 1, 180, 3, 180, 6789, 8, + 180, 1, 180, 3, 180, 6792, 8, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, + 1, 180, 5, 180, 6800, 8, 180, 10, 180, 12, 180, 6803, 9, 180, 3, 180, 6805, + 8, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, + 5, 180, 6815, 8, 180, 10, 180, 12, 180, 6818, 9, 180, 3, 180, 6820, 8, + 180, 1, 180, 3, 180, 6823, 8, 180, 1, 180, 3, 180, 6826, 8, 180, 1, 180, + 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, + 1, 180, 1, 180, 3, 180, 6840, 8, 180, 1, 180, 3, 180, 6843, 8, 180, 1, + 180, 3, 180, 6846, 8, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 3, 180, + 6853, 8, 180, 1, 180, 3, 180, 6856, 8, 180, 1, 180, 1, 180, 1, 180, 1, + 180, 1, 180, 1, 180, 5, 180, 6864, 8, 180, 10, 180, 12, 180, 6867, 9, 180, + 3, 180, 6869, 8, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, + 180, 1, 180, 5, 180, 6879, 8, 180, 10, 180, 12, 180, 6882, 9, 180, 3, 180, + 6884, 8, 180, 1, 180, 3, 180, 6887, 8, 180, 1, 180, 3, 180, 6890, 8, 180, + 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, 1, 180, + 1, 180, 3, 180, 6902, 8, 180, 1, 180, 3, 180, 6905, 8, 180, 1, 180, 3, + 180, 6908, 8, 180, 1, 180, 3, 180, 6911, 8, 180, 1, 180, 1, 180, 1, 180, + 3, 180, 6916, 8, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, + 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1, + 181, 1, 181, 3, 181, 6935, 8, 181, 1, 182, 1, 182, 3, 182, 6939, 8, 182, + 1, 182, 1, 182, 1, 182, 3, 182, 6944, 8, 182, 1, 182, 1, 182, 1, 182, 1, + 182, 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 6955, 8, 182, 1, 182, + 1, 182, 1, 182, 1, 182, 1, 182, 1, 182, 3, 182, 6963, 8, 182, 1, 183, 1, + 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 3, + 185, 6975, 8, 185, 1, 185, 3, 185, 6978, 8, 185, 1, 185, 1, 185, 1, 185, + 3, 185, 6983, 8, 185, 1, 185, 1, 185, 3, 185, 6987, 8, 185, 1, 185, 3, + 185, 6990, 8, 185, 1, 185, 3, 185, 6993, 8, 185, 1, 185, 3, 185, 6996, + 8, 185, 1, 185, 3, 185, 6999, 8, 185, 1, 185, 3, 185, 7002, 8, 185, 1, + 185, 1, 185, 1, 185, 1, 186, 1, 186, 3, 186, 7009, 8, 186, 1, 186, 1, 186, + 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, 3, 186, 7018, 8, 186, 1, 186, 1, + 186, 1, 186, 1, 186, 1, 186, 3, 186, 7025, 8, 186, 1, 186, 3, 186, 7028, + 8, 186, 1, 186, 3, 186, 7031, 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, 3, 187, 7049, 8, 187, 1, 188, 1, 188, 1, 188, 1, 188, + 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, + 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, 1, 188, + 1, 188, 1, 188, 1, 188, 1, 188, 3, 188, 7077, 8, 188, 1, 189, 1, 189, 3, + 189, 7081, 8, 189, 1, 189, 1, 189, 1, 189, 3, 189, 7086, 8, 189, 1, 189, + 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, + 7097, 8, 189, 1, 189, 1, 189, 3, 189, 7101, 8, 189, 1, 189, 1, 189, 1, + 189, 3, 189, 7106, 8, 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, 7120, 8, 189, 3, + 189, 7122, 8, 189, 1, 190, 1, 190, 3, 190, 7126, 8, 190, 1, 190, 1, 190, + 3, 190, 7130, 8, 190, 1, 190, 1, 190, 1, 190, 1, 190, 3, 190, 7136, 8, + 190, 1, 190, 1, 190, 1, 190, 3, 190, 7141, 8, 190, 1, 190, 1, 190, 1, 190, + 3, 190, 7146, 8, 190, 1, 190, 1, 190, 1, 190, 3, 190, 7151, 8, 190, 1, + 190, 3, 190, 7154, 8, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 192, + 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 3, 193, 7167, 8, 193, 1, 194, 1, + 194, 3, 194, 7171, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, + 5, 194, 7179, 8, 194, 10, 194, 12, 194, 7182, 9, 194, 3, 194, 7184, 8, + 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 5, + 194, 7194, 8, 194, 10, 194, 12, 194, 7197, 9, 194, 3, 194, 7199, 8, 194, + 1, 194, 3, 194, 7202, 8, 194, 1, 194, 1, 194, 3, 194, 7206, 8, 194, 1, + 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, + 194, 1, 194, 1, 194, 3, 194, 7220, 8, 194, 1, 194, 3, 194, 7223, 8, 194, + 1, 194, 3, 194, 7226, 8, 194, 1, 194, 3, 194, 7229, 8, 194, 1, 194, 1, + 194, 1, 194, 1, 194, 1, 194, 3, 194, 7236, 8, 194, 1, 194, 3, 194, 7239, + 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 5, 194, 7247, 8, + 194, 10, 194, 12, 194, 7250, 9, 194, 3, 194, 7252, 8, 194, 1, 194, 1, 194, + 1, 194, 1, 194, 1, 194, 3, 194, 7259, 8, 194, 1, 194, 1, 194, 1, 194, 1, + 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, + 194, 7273, 8, 194, 1, 194, 3, 194, 7276, 8, 194, 1, 194, 3, 194, 7279, + 8, 194, 1, 194, 3, 194, 7282, 8, 194, 1, 194, 1, 194, 1, 194, 3, 194, 7287, + 8, 194, 1, 195, 1, 195, 1, 195, 1, 195, 3, 195, 7293, 8, 195, 1, 195, 1, + 195, 1, 195, 1, 195, 1, 195, 1, 195, 5, 195, 7301, 8, 195, 10, 195, 12, + 195, 7304, 9, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 5, 195, 7311, + 8, 195, 10, 195, 12, 195, 7314, 9, 195, 3, 195, 7316, 8, 195, 1, 195, 1, + 195, 1, 195, 1, 195, 1, 195, 5, 195, 7323, 8, 195, 10, 195, 12, 195, 7326, + 9, 195, 3, 195, 7328, 8, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 5, + 195, 7335, 8, 195, 10, 195, 12, 195, 7338, 9, 195, 3, 195, 7340, 8, 195, + 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 5, 195, 7347, 8, 195, 10, 195, + 12, 195, 7350, 9, 195, 1, 195, 1, 195, 1, 195, 3, 195, 7355, 8, 195, 1, + 195, 1, 195, 1, 195, 3, 195, 7360, 8, 195, 1, 195, 1, 195, 1, 195, 1, 195, + 3, 195, 7366, 8, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 1, + 195, 1, 195, 1, 195, 1, 195, 3, 195, 7378, 8, 195, 1, 196, 1, 196, 3, 196, + 7382, 8, 196, 1, 196, 1, 196, 1, 196, 1, 196, 1, 196, 3, 196, 7389, 8, + 196, 1, 196, 3, 196, 7392, 8, 196, 1, 196, 1, 196, 1, 196, 1, 196, 3, 196, + 7398, 8, 196, 3, 196, 7400, 8, 196, 1, 196, 1, 196, 1, 196, 3, 196, 7405, + 8, 196, 1, 196, 3, 196, 7408, 8, 196, 1, 196, 1, 196, 4, 196, 7412, 8, + 196, 11, 196, 12, 196, 7413, 3, 196, 7416, 8, 196, 1, 197, 1, 197, 3, 197, + 7420, 8, 197, 1, 197, 1, 197, 3, 197, 7424, 8, 197, 1, 197, 1, 197, 3, + 197, 7428, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, + 1, 197, 1, 197, 1, 197, 5, 197, 7440, 8, 197, 10, 197, 12, 197, 7443, 9, + 197, 1, 197, 1, 197, 3, 197, 7447, 8, 197, 1, 197, 1, 197, 1, 197, 3, 197, + 7452, 8, 197, 1, 198, 1, 198, 3, 198, 7456, 8, 198, 1, 198, 1, 198, 1, + 198, 1, 198, 3, 198, 7462, 8, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, + 1, 198, 5, 198, 7470, 8, 198, 10, 198, 12, 198, 7473, 9, 198, 1, 198, 1, + 198, 1, 198, 1, 198, 1, 198, 1, 198, 3, 198, 7481, 8, 198, 1, 199, 1, 199, + 3, 199, 7485, 8, 199, 1, 199, 3, 199, 7488, 8, 199, 1, 199, 1, 199, 3, + 199, 7492, 8, 199, 1, 199, 1, 199, 3, 199, 7496, 8, 199, 1, 199, 1, 199, + 1, 199, 3, 199, 7501, 8, 199, 1, 199, 1, 199, 1, 199, 3, 199, 7506, 8, + 199, 1, 199, 1, 199, 1, 199, 3, 199, 7511, 8, 199, 1, 199, 3, 199, 7514, + 8, 199, 1, 199, 3, 199, 7517, 8, 199, 1, 199, 3, 199, 7520, 8, 199, 1, + 200, 1, 200, 3, 200, 7524, 8, 200, 1, 200, 1, 200, 1, 200, 3, 200, 7529, + 8, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, + 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, + 1, 200, 1, 200, 1, 200, 3, 200, 7551, 8, 200, 1, 200, 1, 200, 1, 200, 1, + 200, 1, 200, 1, 200, 3, 200, 7559, 8, 200, 1, 200, 1, 200, 1, 200, 1, 200, + 1, 200, 1, 200, 1, 200, 3, 200, 7568, 8, 200, 3, 200, 7570, 8, 200, 1, + 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 3, 200, 7578, 8, 200, 1, 200, + 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 3, 200, 7586, 8, 200, 1, 200, 1, + 200, 1, 200, 3, 200, 7591, 8, 200, 1, 200, 1, 200, 1, 200, 3, 200, 7596, + 8, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 1, 200, 3, 200, 7604, 8, + 200, 1, 200, 1, 200, 1, 200, 3, 200, 7609, 8, 200, 1, 200, 1, 200, 1, 200, + 3, 200, 7614, 8, 200, 1, 201, 1, 201, 1, 202, 1, 202, 3, 202, 7620, 8, + 202, 1, 202, 1, 202, 1, 202, 3, 202, 7625, 8, 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, + 7638, 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7643, 8, 202, 1, 202, 1, + 202, 1, 202, 3, 202, 7648, 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7653, + 8, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7661, 8, + 202, 1, 202, 3, 202, 7664, 8, 202, 1, 202, 1, 202, 3, 202, 7668, 8, 202, + 1, 202, 1, 202, 1, 202, 3, 202, 7673, 8, 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, 7686, + 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7691, 8, 202, 1, 202, 1, 202, 1, + 202, 3, 202, 7696, 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7701, 8, 202, + 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7709, 8, 202, 1, + 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7717, 8, 202, 1, 202, + 1, 202, 1, 202, 3, 202, 7722, 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7727, + 8, 202, 1, 202, 3, 202, 7730, 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7735, + 8, 202, 1, 202, 1, 202, 1, 202, 3, 202, 7740, 8, 202, 1, 202, 3, 202, 7743, + 8, 202, 3, 202, 7745, 8, 202, 1, 203, 1, 203, 3, 203, 7749, 8, 203, 1, + 203, 1, 203, 1, 203, 3, 203, 7754, 8, 203, 1, 203, 1, 203, 1, 203, 1, 203, + 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, + 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 1, 203, 3, 203, 7775, 8, 203, 1, + 203, 1, 203, 1, 203, 3, 203, 7780, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, + 7785, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 7790, 8, 203, 1, 203, 1, + 203, 1, 203, 3, 203, 7795, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 7800, + 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 7805, 8, 203, 1, 203, 1, 203, 1, + 203, 3, 203, 7810, 8, 203, 1, 203, 1, 203, 1, 203, 3, 203, 7815, 8, 203, + 1, 204, 1, 204, 3, 204, 7819, 8, 204, 1, 204, 1, 204, 1, 204, 3, 204, 7824, + 8, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, + 1, 204, 1, 204, 1, 204, 3, 204, 7837, 8, 204, 1, 204, 1, 204, 1, 204, 3, + 204, 7842, 8, 204, 1, 204, 3, 204, 7845, 8, 204, 1, 205, 1, 205, 1, 205, + 1, 205, 1, 206, 1, 206, 1, 207, 1, 207, 3, 207, 7855, 8, 207, 1, 207, 3, + 207, 7858, 8, 207, 1, 207, 1, 207, 1, 208, 1, 208, 3, 208, 7864, 8, 208, + 1, 208, 3, 208, 7867, 8, 208, 1, 208, 1, 208, 1, 209, 1, 209, 3, 209, 7873, + 8, 209, 1, 209, 1, 209, 3, 209, 7877, 8, 209, 1, 209, 1, 209, 3, 209, 7881, + 8, 209, 1, 209, 3, 209, 7884, 8, 209, 1, 209, 3, 209, 7887, 8, 209, 1, + 209, 3, 209, 7890, 8, 209, 1, 210, 1, 210, 3, 210, 7894, 8, 210, 1, 210, + 1, 210, 1, 210, 3, 210, 7899, 8, 210, 1, 210, 1, 210, 1, 210, 1, 210, 3, + 210, 7905, 8, 210, 1, 210, 1, 210, 1, 210, 3, 210, 7910, 8, 210, 1, 210, + 3, 210, 7913, 8, 210, 1, 211, 1, 211, 3, 211, 7917, 8, 211, 1, 211, 1, + 211, 1, 211, 3, 211, 7922, 8, 211, 1, 212, 1, 212, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 7933, 8, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 3, 213, 7939, 8, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, + 7954, 8, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 7960, 8, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 3, 213, 7966, 8, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 7976, 8, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 3, 213, 7983, 8, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 3, 213, 7993, 8, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 3, 213, 8017, 8, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, + 3, 213, 8068, 8, 213, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, + 214, 3, 214, 8077, 8, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, + 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, + 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 3, 214, + 8102, 8, 214, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, 215, 1, + 215, 3, 215, 8112, 8, 215, 1, 216, 1, 216, 1, 216, 1, 216, 1, 217, 1, 217, + 1, 217, 1, 217, 1, 218, 1, 218, 1, 218, 1, 218, 1, 219, 1, 219, 1, 219, + 1, 219, 3, 219, 8130, 8, 219, 1, 219, 1, 219, 3, 219, 8134, 8, 219, 1, + 219, 1, 219, 3, 219, 8138, 8, 219, 3, 219, 8140, 8, 219, 1, 219, 3, 219, + 8143, 8, 219, 3, 219, 8145, 8, 219, 1, 219, 1, 219, 1, 220, 1, 220, 1, + 220, 1, 220, 1, 221, 1, 221, 1, 221, 1, 221, 1, 222, 1, 222, 1, 222, 1, + 222, 1, 223, 1, 223, 1, 223, 1, 223, 1, 224, 1, 224, 1, 224, 1, 224, 1, + 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 8177, + 8, 224, 1, 224, 3, 224, 8180, 8, 224, 1, 224, 1, 224, 3, 224, 8184, 8, + 224, 1, 224, 3, 224, 8187, 8, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, + 1, 224, 3, 224, 8195, 8, 224, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 8201, + 8, 224, 1, 224, 1, 224, 1, 224, 3, 224, 8206, 8, 224, 1, 224, 1, 224, 1, + 224, 3, 224, 8211, 8, 224, 3, 224, 8213, 8, 224, 3, 224, 8215, 8, 224, + 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, + 1, 224, 1, 224, 1, 224, 3, 224, 8229, 8, 224, 1, 224, 3, 224, 8232, 8, + 224, 1, 224, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 8239, 8, 224, 1, 224, + 1, 224, 1, 224, 3, 224, 8244, 8, 224, 1, 224, 1, 224, 1, 224, 3, 224, 8249, + 8, 224, 1, 224, 3, 224, 8252, 8, 224, 3, 224, 8254, 8, 224, 1, 225, 1, + 225, 1, 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 1, 227, 1, 227, 1, + 228, 1, 228, 1, 228, 1, 228, 1, 229, 1, 229, 1, 229, 1, 229, 1, 230, 1, + 230, 1, 230, 1, 230, 1, 230, 3, 230, 8279, 8, 230, 1, 230, 1, 230, 1, 230, + 1, 230, 1, 230, 1, 230, 1, 230, 3, 230, 8288, 8, 230, 1, 230, 3, 230, 8291, + 8, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 3, 230, + 8300, 8, 230, 1, 230, 3, 230, 8303, 8, 230, 1, 230, 3, 230, 8306, 8, 230, + 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 1, 230, 3, 230, 8315, 8, + 230, 1, 230, 3, 230, 8318, 8, 230, 1, 230, 3, 230, 8321, 8, 230, 1, 230, + 1, 230, 3, 230, 8325, 8, 230, 1, 231, 1, 231, 3, 231, 8329, 8, 231, 1, + 231, 3, 231, 8332, 8, 231, 1, 231, 1, 231, 3, 231, 8336, 8, 231, 1, 231, + 1, 231, 3, 231, 8340, 8, 231, 1, 231, 3, 231, 8343, 8, 231, 1, 231, 1, + 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 5, + 231, 8355, 8, 231, 10, 231, 12, 231, 8358, 9, 231, 3, 231, 8360, 8, 231, + 1, 231, 3, 231, 8363, 8, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, + 231, 3, 231, 8371, 8, 231, 1, 231, 3, 231, 8374, 8, 231, 1, 231, 3, 231, + 8377, 8, 231, 1, 231, 1, 231, 3, 231, 8381, 8, 231, 1, 231, 3, 231, 8384, + 8, 231, 1, 231, 1, 231, 3, 231, 8388, 8, 231, 1, 231, 1, 231, 1, 231, 3, + 231, 8393, 8, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, 1, 231, + 1, 231, 1, 231, 1, 231, 5, 231, 8405, 8, 231, 10, 231, 12, 231, 8408, 9, + 231, 3, 231, 8410, 8, 231, 1, 231, 3, 231, 8413, 8, 231, 1, 231, 1, 231, + 1, 231, 1, 231, 1, 231, 1, 231, 3, 231, 8421, 8, 231, 1, 231, 3, 231, 8424, + 8, 231, 1, 231, 3, 231, 8427, 8, 231, 3, 231, 8429, 8, 231, 1, 232, 1, + 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 3, 232, 8440, + 8, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 3, 232, 8451, 8, 232, 1, 233, 1, 233, 1, 233, 1, 233, 1, 233, 1, + 233, 3, 233, 8459, 8, 233, 1, 233, 1, 233, 1, 233, 3, 233, 8464, 8, 233, + 1, 234, 1, 234, 1, 234, 1, 234, 1, 235, 1, 235, 3, 235, 8472, 8, 235, 1, + 235, 1, 235, 1, 235, 3, 235, 8477, 8, 235, 1, 235, 1, 235, 1, 235, 1, 235, + 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, + 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 1, 235, 3, 235, 8498, 8, 235, 1, + 235, 3, 235, 8501, 8, 235, 1, 236, 1, 236, 1, 236, 1, 237, 1, 237, 1, 237, + 1, 237, 1, 238, 1, 238, 1, 238, 1, 238, 1, 239, 1, 239, 1, 239, 1, 239, + 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, + 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 3, 240, 8532, 8, 240, 1, 240, 1, + 240, 1, 241, 1, 241, 3, 241, 8538, 8, 241, 1, 241, 1, 241, 3, 241, 8542, + 8, 241, 1, 241, 1, 241, 3, 241, 8546, 8, 241, 1, 241, 1, 241, 1, 241, 1, + 241, 3, 241, 8552, 8, 241, 1, 241, 3, 241, 8555, 8, 241, 1, 241, 3, 241, + 8558, 8, 241, 1, 241, 3, 241, 8561, 8, 241, 1, 241, 1, 241, 3, 241, 8565, + 8, 241, 1, 241, 1, 241, 3, 241, 8569, 8, 241, 1, 241, 1, 241, 3, 241, 8573, + 8, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 3, 241, 8580, 8, 241, 1, + 241, 3, 241, 8583, 8, 241, 1, 241, 3, 241, 8586, 8, 241, 1, 241, 1, 241, + 3, 241, 8590, 8, 241, 1, 241, 1, 241, 3, 241, 8594, 8, 241, 1, 241, 1, + 241, 3, 241, 8598, 8, 241, 1, 241, 1, 241, 1, 241, 1, 241, 3, 241, 8604, + 8, 241, 1, 241, 1, 241, 3, 241, 8608, 8, 241, 1, 241, 1, 241, 3, 241, 8612, + 8, 241, 1, 241, 1, 241, 3, 241, 8616, 8, 241, 1, 241, 1, 241, 1, 241, 1, + 241, 3, 241, 8622, 8, 241, 1, 241, 3, 241, 8625, 8, 241, 1, 241, 3, 241, + 8628, 8, 241, 1, 241, 3, 241, 8631, 8, 241, 3, 241, 8633, 8, 241, 1, 242, + 1, 242, 1, 243, 3, 243, 8638, 8, 243, 1, 243, 1, 243, 3, 243, 8642, 8, + 243, 1, 243, 3, 243, 8645, 8, 243, 1, 244, 3, 244, 8648, 8, 244, 1, 244, + 1, 244, 1, 244, 1, 244, 1, 244, 5, 244, 8655, 8, 244, 10, 244, 12, 244, + 8658, 9, 244, 1, 244, 1, 244, 1, 245, 3, 245, 8663, 8, 245, 1, 245, 1, + 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 5, 245, 8674, + 8, 245, 10, 245, 12, 245, 8677, 9, 245, 1, 245, 1, 245, 1, 246, 1, 246, + 1, 246, 1, 246, 1, 247, 1, 247, 1, 247, 1, 247, 1, 248, 3, 248, 8690, 8, + 248, 1, 248, 1, 248, 1, 248, 1, 248, 1, 248, 3, 248, 8697, 8, 248, 1, 249, + 1, 249, 1, 249, 1, 250, 1, 250, 1, 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, 1, 251, + 1, 251, 3, 251, 8719, 8, 251, 3, 251, 8721, 8, 251, 1, 252, 1, 252, 1, + 252, 1, 253, 1, 253, 3, 253, 8728, 8, 253, 1, 253, 1, 253, 3, 253, 8732, + 8, 253, 1, 253, 1, 253, 1, 253, 3, 253, 8737, 8, 253, 1, 253, 3, 253, 8740, + 8, 253, 1, 253, 3, 253, 8743, 8, 253, 1, 253, 1, 253, 1, 253, 3, 253, 8748, + 8, 253, 3, 253, 8750, 8, 253, 1, 253, 3, 253, 8753, 8, 253, 1, 254, 1, + 254, 1, 254, 1, 254, 1, 254, 5, 254, 8760, 8, 254, 10, 254, 12, 254, 8763, + 9, 254, 1, 254, 3, 254, 8766, 8, 254, 1, 254, 3, 254, 8769, 8, 254, 1, + 254, 1, 254, 3, 254, 8773, 8, 254, 1, 255, 1, 255, 3, 255, 8777, 8, 255, + 1, 256, 1, 256, 1, 256, 5, 256, 8782, 8, 256, 10, 256, 12, 256, 8785, 9, + 256, 1, 257, 1, 257, 3, 257, 8789, 8, 257, 1, 257, 3, 257, 8792, 8, 257, + 1, 257, 1, 257, 3, 257, 8796, 8, 257, 1, 257, 1, 257, 1, 257, 3, 257, 8801, + 8, 257, 3, 257, 8803, 8, 257, 1, 257, 1, 257, 1, 257, 1, 257, 3, 257, 8809, + 8, 257, 1, 257, 3, 257, 8812, 8, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, + 257, 1, 257, 3, 257, 8820, 8, 257, 1, 257, 1, 257, 1, 257, 3, 257, 8825, + 8, 257, 1, 257, 1, 257, 1, 257, 3, 257, 8830, 8, 257, 1, 257, 3, 257, 8833, + 8, 257, 1, 257, 3, 257, 8836, 8, 257, 1, 257, 3, 257, 8839, 8, 257, 1, + 257, 3, 257, 8842, 8, 257, 1, 257, 3, 257, 8845, 8, 257, 1, 257, 3, 257, + 8848, 8, 257, 1, 258, 1, 258, 3, 258, 8852, 8, 258, 1, 258, 3, 258, 8855, + 8, 258, 1, 258, 1, 258, 3, 258, 8859, 8, 258, 1, 258, 1, 258, 1, 258, 3, + 258, 8864, 8, 258, 3, 258, 8866, 8, 258, 1, 258, 1, 258, 1, 258, 1, 258, + 3, 258, 8872, 8, 258, 1, 258, 3, 258, 8875, 8, 258, 1, 258, 3, 258, 8878, + 8, 258, 1, 258, 3, 258, 8881, 8, 258, 1, 258, 3, 258, 8884, 8, 258, 1, + 258, 3, 258, 8887, 8, 258, 1, 258, 1, 258, 1, 258, 1, 259, 1, 259, 3, 259, + 8894, 8, 259, 1, 259, 1, 259, 3, 259, 8898, 8, 259, 1, 259, 1, 259, 3, + 259, 8902, 8, 259, 1, 259, 1, 259, 3, 259, 8906, 8, 259, 1, 259, 1, 259, + 3, 259, 8910, 8, 259, 1, 259, 1, 259, 1, 259, 1, 259, 1, 259, 5, 259, 8917, + 8, 259, 10, 259, 12, 259, 8920, 9, 259, 3, 259, 8922, 8, 259, 3, 259, 8924, + 8, 259, 1, 260, 1, 260, 1, 261, 1, 261, 1, 261, 5, 261, 8931, 8, 261, 10, + 261, 12, 261, 8934, 9, 261, 1, 262, 1, 262, 1, 262, 5, 262, 8939, 8, 262, + 10, 262, 12, 262, 8942, 9, 262, 1, 263, 1, 263, 1, 263, 1, 263, 1, 264, + 1, 264, 3, 264, 8950, 8, 264, 1, 264, 1, 264, 3, 264, 8954, 8, 264, 1, + 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 1, 264, 3, 264, 8963, 8, 264, + 1, 264, 1, 264, 1, 264, 3, 264, 8968, 8, 264, 1, 264, 1, 264, 1, 264, 3, + 264, 8973, 8, 264, 1, 264, 3, 264, 8976, 8, 264, 1, 264, 1, 264, 1, 264, + 3, 264, 8981, 8, 264, 1, 264, 1, 264, 1, 264, 3, 264, 8986, 8, 264, 1, + 264, 1, 264, 1, 264, 3, 264, 8991, 8, 264, 1, 264, 3, 264, 8994, 8, 264, + 1, 264, 3, 264, 8997, 8, 264, 1, 264, 1, 264, 1, 264, 1, 264, 5, 264, 9003, + 8, 264, 10, 264, 12, 264, 9006, 9, 264, 3, 264, 9008, 8, 264, 1, 264, 1, + 264, 3, 264, 9012, 8, 264, 1, 264, 1, 264, 1, 264, 1, 265, 1, 265, 1, 265, + 3, 265, 9020, 8, 265, 1, 266, 1, 266, 1, 266, 1, 266, 3, 266, 9026, 8, + 266, 1, 266, 1, 266, 1, 267, 1, 267, 3, 267, 9032, 8, 267, 1, 267, 1, 267, + 3, 267, 9036, 8, 267, 1, 267, 1, 267, 3, 267, 9040, 8, 267, 1, 267, 3, + 267, 9043, 8, 267, 1, 267, 3, 267, 9046, 8, 267, 1, 268, 1, 268, 1, 268, + 1, 268, 1, 269, 1, 269, 3, 269, 9054, 8, 269, 1, 269, 3, 269, 9057, 8, + 269, 1, 269, 3, 269, 9060, 8, 269, 1, 269, 1, 269, 3, 269, 9064, 8, 269, + 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 3, 269, 9071, 8, 269, 1, 269, 5, + 269, 9074, 8, 269, 10, 269, 12, 269, 9077, 9, 269, 1, 269, 3, 269, 9080, + 8, 269, 1, 269, 3, 269, 9083, 8, 269, 1, 269, 3, 269, 9086, 8, 269, 1, + 269, 3, 269, 9089, 8, 269, 1, 269, 1, 269, 1, 269, 1, 270, 1, 270, 3, 270, + 9096, 8, 270, 1, 270, 1, 270, 3, 270, 9100, 8, 270, 1, 270, 1, 270, 3, + 270, 9104, 8, 270, 1, 270, 4, 270, 9107, 8, 270, 11, 270, 12, 270, 9108, + 3, 270, 9111, 8, 270, 1, 270, 5, 270, 9114, 8, 270, 10, 270, 12, 270, 9117, + 9, 270, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, + 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, + 3, 271, 9136, 8, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, + 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, 271, 1, + 271, 3, 271, 9154, 8, 271, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, 1, 272, + 1, 272, 1, 272, 1, 272, 1, 272, 3, 272, 9166, 8, 272, 3, 272, 9168, 8, + 272, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 273, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, + 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 1, 274, 3, 274, 9203, 8, 274, + 1, 275, 1, 275, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 3, 276, 9239, 8, + 276, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 3, 277, 9246, 8, 277, 1, 278, + 1, 278, 1, 278, 1, 278, 1, 279, 1, 279, 1, 279, 3, 279, 9255, 8, 279, 1, + 279, 1, 279, 1, 280, 1, 280, 1, 280, 3, 280, 9262, 8, 280, 1, 280, 1, 280, + 3, 280, 9266, 8, 280, 1, 281, 1, 281, 1, 281, 1, 281, 3, 281, 9272, 8, + 281, 1, 281, 1, 281, 1, 282, 1, 282, 1, 282, 1, 282, 3, 282, 9280, 8, 282, + 1, 282, 1, 282, 3, 282, 9284, 8, 282, 1, 283, 1, 283, 1, 283, 1, 283, 3, + 283, 9290, 8, 283, 1, 283, 1, 283, 1, 284, 1, 284, 1, 284, 1, 284, 3, 284, + 9298, 8, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 3, 285, 9305, 8, + 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 3, 286, 9312, 8, 286, 1, 286, + 1, 286, 3, 286, 9316, 8, 286, 1, 286, 1, 286, 1, 287, 1, 287, 1, 287, 1, + 287, 1, 287, 1, 288, 1, 288, 1, 288, 1, 288, 1, 288, 1, 289, 1, 289, 1, + 289, 1, 289, 3, 289, 9334, 8, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, + 1, 290, 3, 290, 9342, 8, 290, 1, 290, 1, 290, 1, 291, 1, 291, 1, 291, 3, + 291, 9349, 8, 291, 1, 291, 1, 291, 1, 292, 1, 292, 1, 292, 3, 292, 9356, + 8, 292, 1, 292, 1, 292, 1, 292, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, + 9365, 8, 293, 1, 293, 1, 293, 1, 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, + 295, 1, 295, 1, 295, 3, 295, 9377, 8, 295, 1, 295, 1, 295, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 296, 3, 296, 9386, 8, 296, 1, 296, 1, 296, 1, 297, 1, + 297, 1, 297, 3, 297, 9393, 8, 297, 1, 297, 1, 297, 3, 297, 9397, 8, 297, + 1, 298, 1, 298, 1, 298, 3, 298, 9402, 8, 298, 1, 298, 1, 298, 3, 298, 9406, + 8, 298, 1, 299, 1, 299, 1, 299, 1, 299, 3, 299, 9412, 8, 299, 1, 299, 1, + 299, 1, 300, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, 3, 301, 9423, + 8, 301, 1, 301, 1, 301, 1, 302, 1, 302, 1, 302, 3, 302, 9430, 8, 302, 1, + 302, 1, 302, 1, 303, 1, 303, 1, 303, 3, 303, 9437, 8, 303, 1, 303, 1, 303, + 3, 303, 9441, 8, 303, 1, 304, 1, 304, 1, 304, 3, 304, 9446, 8, 304, 1, + 304, 1, 304, 1, 305, 1, 305, 1, 305, 3, 305, 9453, 8, 305, 1, 305, 1, 305, + 1, 306, 1, 306, 1, 306, 3, 306, 9460, 8, 306, 1, 306, 1, 306, 1, 307, 1, + 307, 1, 307, 3, 307, 9467, 8, 307, 1, 307, 1, 307, 1, 308, 1, 308, 1, 308, + 3, 308, 9474, 8, 308, 1, 308, 1, 308, 1, 309, 1, 309, 1, 310, 1, 310, 3, + 310, 9482, 8, 310, 1, 310, 1, 310, 1, 311, 1, 311, 1, 311, 1, 311, 1, 311, + 3, 311, 9491, 8, 311, 1, 312, 1, 312, 1, 312, 1, 312, 1, 313, 1, 313, 1, + 313, 1, 313, 1, 313, 1, 314, 1, 314, 1, 314, 1, 314, 1, 315, 1, 315, 1, + 315, 1, 315, 1, 316, 1, 316, 1, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, + 317, 1, 317, 3, 317, 9519, 8, 317, 1, 318, 1, 318, 1, 318, 1, 318, 1, 319, + 1, 319, 1, 319, 1, 319, 1, 320, 1, 320, 3, 320, 9531, 8, 320, 1, 320, 1, + 320, 1, 320, 3, 320, 9536, 8, 320, 1, 320, 1, 320, 1, 321, 1, 321, 1, 321, + 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 323, 1, 323, 1, 323, + 1, 323, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 1, 326, 1, 326, + 1, 326, 1, 326, 1, 327, 1, 327, 1, 327, 1, 328, 1, 328, 1, 329, 1, 329, + 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, + 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, + 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 9595, 8, + 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 331, 1, 331, 1, + 332, 1, 332, 1, 332, 1, 332, 1, 332, 1, 333, 1, 333, 3, 333, 9612, 8, 333, + 1, 333, 1, 333, 1, 333, 1, 333, 1, 333, 3, 333, 9619, 8, 333, 1, 334, 1, + 334, 1, 334, 1, 334, 1, 334, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, + 336, 1, 336, 3, 336, 9633, 8, 336, 1, 336, 1, 336, 1, 336, 1, 337, 1, 337, + 1, 337, 1, 337, 1, 337, 1, 338, 1, 338, 1, 338, 1, 338, 1, 338, 1, 339, + 1, 339, 1, 339, 1, 339, 1, 339, 1, 340, 1, 340, 1, 340, 1, 340, 1, 341, + 1, 341, 1, 341, 1, 341, 1, 341, 1, 342, 1, 342, 1, 342, 1, 342, 1, 342, + 1, 342, 3, 342, 9668, 8, 342, 1, 343, 1, 343, 1, 343, 1, 343, 1, 343, 1, + 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 1, + 345, 1, 345, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 1, + 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 349, 1, 349, 1, 349, 1, + 349, 1, 350, 1, 350, 1, 350, 1, 350, 1, 351, 1, 351, 1, 351, 1, 351, 1, + 351, 1, 351, 3, 351, 9713, 8, 351, 1, 352, 1, 352, 1, 352, 1, 352, 1, 353, + 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, + 1, 355, 1, 355, 1, 356, 1, 356, 1, 356, 1, 356, 1, 357, 1, 357, 1, 357, + 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, + 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, + 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, + 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, + 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, + 1, 357, 1, 357, 1, 357, 3, 357, 9786, 8, 357, 1, 358, 1, 358, 3, 358, 9790, + 8, 358, 1, 358, 1, 358, 3, 358, 9794, 8, 358, 1, 358, 1, 358, 1, 358, 1, + 358, 3, 358, 9800, 8, 358, 1, 358, 1, 358, 3, 358, 9804, 8, 358, 3, 358, + 9806, 8, 358, 3, 358, 9808, 8, 358, 1, 358, 3, 358, 9811, 8, 358, 1, 358, + 3, 358, 9814, 8, 358, 1, 359, 1, 359, 1, 359, 3, 359, 9819, 8, 359, 1, + 359, 1, 359, 1, 359, 1, 359, 3, 359, 9825, 8, 359, 1, 359, 1, 359, 3, 359, + 9829, 8, 359, 1, 359, 1, 359, 3, 359, 9833, 8, 359, 1, 359, 1, 359, 1, + 359, 3, 359, 9838, 8, 359, 1, 359, 3, 359, 9841, 8, 359, 3, 359, 9843, + 8, 359, 1, 360, 1, 360, 1, 360, 3, 360, 9848, 8, 360, 1, 361, 1, 361, 1, + 361, 1, 361, 1, 362, 1, 362, 1, 362, 1, 362, 3, 362, 9858, 8, 362, 1, 363, + 1, 363, 3, 363, 9862, 8, 363, 1, 363, 1, 363, 3, 363, 9866, 8, 363, 1, + 363, 3, 363, 9869, 8, 363, 1, 363, 3, 363, 9872, 8, 363, 1, 363, 3, 363, + 9875, 8, 363, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, + 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 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, 3, 366, 9907, 8, 366, 1, 367, 1, 367, + 1, 367, 1, 367, 3, 367, 9913, 8, 367, 1, 368, 1, 368, 1, 368, 1, 368, 3, + 368, 9919, 8, 368, 1, 368, 1, 368, 1, 368, 1, 368, 3, 368, 9925, 8, 368, + 1, 368, 3, 368, 9928, 8, 368, 1, 368, 3, 368, 9931, 8, 368, 3, 368, 9933, + 8, 368, 3, 368, 9935, 8, 368, 1, 368, 3, 368, 9938, 8, 368, 1, 368, 3, + 368, 9941, 8, 368, 1, 369, 1, 369, 3, 369, 9945, 8, 369, 1, 369, 1, 369, + 1, 369, 3, 369, 9950, 8, 369, 1, 369, 1, 369, 1, 369, 1, 369, 3, 369, 9956, + 8, 369, 1, 369, 3, 369, 9959, 8, 369, 1, 369, 3, 369, 9962, 8, 369, 3, + 369, 9964, 8, 369, 3, 369, 9966, 8, 369, 1, 369, 3, 369, 9969, 8, 369, + 1, 369, 3, 369, 9972, 8, 369, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, + 370, 3, 370, 9980, 8, 370, 1, 371, 1, 371, 1, 371, 1, 371, 3, 371, 9986, + 8, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, + 1, 371, 3, 371, 9997, 8, 371, 3, 371, 9999, 8, 371, 1, 372, 1, 372, 1, + 372, 3, 372, 10004, 8, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, + 372, 1, 372, 1, 372, 1, 372, 3, 372, 10015, 8, 372, 3, 372, 10017, 8, 372, + 1, 373, 1, 373, 1, 373, 1, 373, 3, 373, 10023, 8, 373, 1, 374, 1, 374, + 1, 374, 3, 374, 10028, 8, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, + 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 10042, + 8, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, + 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 10057, 8, 375, 1, 375, + 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 10065, 8, 375, 1, 376, + 1, 376, 3, 376, 10069, 8, 376, 1, 376, 1, 376, 3, 376, 10073, 8, 376, 1, + 377, 1, 377, 1, 377, 1, 377, 3, 377, 10079, 8, 377, 1, 378, 1, 378, 1, + 378, 1, 378, 3, 378, 10085, 8, 378, 1, 379, 1, 379, 1, 379, 1, 379, 3, + 379, 10091, 8, 379, 1, 379, 3, 379, 10094, 8, 379, 1, 380, 1, 380, 1, 380, + 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 1, 380, 3, 380, 10105, 8, 380, + 1, 381, 1, 381, 1, 381, 1, 381, 3, 381, 10111, 8, 381, 1, 381, 1, 381, + 3, 381, 10115, 8, 381, 1, 381, 1, 381, 1, 381, 3, 381, 10120, 8, 381, 1, + 382, 1, 382, 1, 382, 1, 382, 3, 382, 10126, 8, 382, 1, 382, 3, 382, 10129, + 8, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 1, 384, 3, 384, + 10138, 8, 384, 1, 384, 3, 384, 10141, 8, 384, 1, 385, 1, 385, 1, 385, 1, + 385, 3, 385, 10147, 8, 385, 1, 386, 1, 386, 1, 387, 1, 387, 1, 387, 3, + 387, 10154, 8, 387, 1, 387, 1, 387, 1, 387, 1, 387, 1, 387, 3, 387, 10161, + 8, 387, 1, 387, 1, 387, 3, 387, 10165, 8, 387, 1, 387, 1, 387, 3, 387, + 10169, 8, 387, 3, 387, 10171, 8, 387, 1, 388, 1, 388, 1, 388, 3, 388, 10176, + 8, 388, 1, 388, 3, 388, 10179, 8, 388, 1, 389, 1, 389, 3, 389, 10183, 8, + 389, 1, 389, 1, 389, 1, 389, 3, 389, 10188, 8, 389, 1, 390, 1, 390, 1, + 390, 3, 390, 10193, 8, 390, 1, 390, 3, 390, 10196, 8, 390, 1, 391, 1, 391, + 1, 391, 3, 391, 10201, 8, 391, 1, 392, 1, 392, 1, 392, 1, 392, 3, 392, + 10207, 8, 392, 1, 393, 1, 393, 1, 393, 1, 393, 3, 393, 10213, 8, 393, 1, + 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 3, 393, 10221, 8, 393, 1, + 394, 1, 394, 1, 394, 1, 394, 1, 394, 1, 394, 3, 394, 10229, 8, 394, 1, + 395, 1, 395, 1, 395, 1, 395, 3, 395, 10235, 8, 395, 1, 396, 1, 396, 1, + 396, 3, 396, 10240, 8, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, 3, + 397, 10247, 8, 397, 1, 397, 3, 397, 10250, 8, 397, 1, 398, 1, 398, 3, 398, + 10254, 8, 398, 1, 398, 1, 398, 3, 398, 10258, 8, 398, 1, 398, 3, 398, 10261, + 8, 398, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 10267, 8, 398, 3, 398, + 10269, 8, 398, 3, 398, 10271, 8, 398, 1, 398, 3, 398, 10274, 8, 398, 1, + 398, 3, 398, 10277, 8, 398, 1, 399, 1, 399, 1, 399, 3, 399, 10282, 8, 399, + 1, 399, 3, 399, 10285, 8, 399, 1, 400, 1, 400, 1, 400, 1, 400, 1, 401, + 1, 401, 1, 401, 3, 401, 10294, 8, 401, 1, 402, 1, 402, 1, 402, 1, 402, + 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, 1, 403, + 1, 403, 1, 404, 1, 404, 1, 404, 3, 404, 10313, 8, 404, 1, 404, 3, 404, + 10316, 8, 404, 1, 405, 1, 405, 1, 405, 3, 405, 10321, 8, 405, 1, 405, 3, + 405, 10324, 8, 405, 1, 406, 1, 406, 1, 406, 3, 406, 10329, 8, 406, 1, 406, + 3, 406, 10332, 8, 406, 1, 407, 1, 407, 1, 407, 3, 407, 10337, 8, 407, 1, + 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 3, + 407, 10348, 8, 407, 1, 408, 1, 408, 3, 408, 10352, 8, 408, 1, 408, 1, 408, + 3, 408, 10356, 8, 408, 1, 408, 1, 408, 1, 408, 1, 408, 3, 408, 10362, 8, + 408, 1, 408, 3, 408, 10365, 8, 408, 1, 408, 3, 408, 10368, 8, 408, 3, 408, + 10370, 8, 408, 3, 408, 10372, 8, 408, 1, 408, 3, 408, 10375, 8, 408, 1, + 408, 3, 408, 10378, 8, 408, 1, 409, 1, 409, 1, 409, 1, 409, 3, 409, 10384, + 8, 409, 1, 410, 1, 410, 1, 410, 1, 410, 3, 410, 10390, 8, 410, 1, 410, + 3, 410, 10393, 8, 410, 1, 411, 1, 411, 3, 411, 10397, 8, 411, 1, 411, 1, + 411, 3, 411, 10401, 8, 411, 1, 411, 1, 411, 1, 411, 3, 411, 10406, 8, 411, + 1, 411, 1, 411, 3, 411, 10410, 8, 411, 1, 411, 1, 411, 3, 411, 10414, 8, + 411, 1, 412, 1, 412, 1, 412, 3, 412, 10419, 8, 412, 1, 413, 1, 413, 3, + 413, 10423, 8, 413, 1, 413, 1, 413, 3, 413, 10427, 8, 413, 1, 413, 1, 413, + 1, 413, 1, 413, 3, 413, 10433, 8, 413, 1, 413, 3, 413, 10436, 8, 413, 1, + 413, 3, 413, 10439, 8, 413, 3, 413, 10441, 8, 413, 3, 413, 10443, 8, 413, + 1, 413, 3, 413, 10446, 8, 413, 1, 413, 3, 413, 10449, 8, 413, 1, 414, 1, + 414, 1, 414, 3, 414, 10454, 8, 414, 1, 415, 1, 415, 1, 415, 1, 416, 1, + 416, 1, 417, 1, 417, 1, 417, 1, 417, 1, 417, 3, 417, 10466, 8, 417, 1, + 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, + 418, 1, 418, 1, 418, 3, 418, 10480, 8, 418, 1, 419, 1, 419, 1, 419, 5, + 419, 10485, 8, 419, 10, 419, 12, 419, 10488, 9, 419, 1, 420, 1, 420, 1, + 421, 1, 421, 1, 422, 1, 422, 1, 423, 1, 423, 1, 424, 1, 424, 1, 425, 1, + 425, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 5, 427, 10507, 8, 427, 10, + 427, 12, 427, 10510, 9, 427, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, + 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 1, 428, 3, 428, 10524, 8, + 428, 1, 429, 1, 429, 1, 430, 1, 430, 1, 431, 1, 431, 1, 432, 1, 432, 1, + 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 1, 433, 3, 433, 10541, 8, + 433, 1, 434, 1, 434, 1, 434, 1, 434, 1, 434, 3, 434, 10548, 8, 434, 1, + 435, 1, 435, 1, 435, 3, 435, 10553, 8, 435, 1, 436, 1, 436, 1, 436, 1, + 436, 1, 437, 1, 437, 1, 438, 1, 438, 1, 438, 5, 438, 10564, 8, 438, 10, + 438, 12, 438, 10567, 9, 438, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, + 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 3, 439, 10580, 8, 439, 1, + 440, 1, 440, 1, 441, 1, 441, 1, 441, 5, 441, 10587, 8, 441, 10, 441, 12, + 441, 10590, 9, 441, 1, 442, 1, 442, 3, 442, 10594, 8, 442, 1, 442, 1, 442, + 1, 442, 3, 442, 10599, 8, 442, 5, 442, 10601, 8, 442, 10, 442, 12, 442, + 10604, 9, 442, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 5, 443, 10640, 8, 443, 10, 443, 12, 443, 10643, 9, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 3, 443, 10663, + 8, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 3, 443, 10683, 8, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, + 3, 443, 10708, 8, 443, 1, 443, 1, 443, 1, 443, 1, 443, 3, 443, 10714, 8, + 443, 1, 443, 1, 443, 1, 443, 1, 443, 3, 443, 10720, 8, 443, 1, 443, 1, + 443, 1, 443, 1, 443, 3, 443, 10726, 8, 443, 1, 443, 1, 443, 3, 443, 10730, + 8, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 1, 443, 5, 443, 10738, + 8, 443, 10, 443, 12, 443, 10741, 9, 443, 1, 443, 1, 443, 1, 443, 3, 443, + 10746, 8, 443, 5, 443, 10748, 8, 443, 10, 443, 12, 443, 10751, 9, 443, + 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, + 1, 445, 1, 445, 1, 445, 1, 445, 1, 445, 5, 445, 10767, 8, 445, 10, 445, + 12, 445, 10770, 9, 445, 1, 445, 1, 445, 1, 446, 1, 446, 1, 446, 1, 446, + 1, 446, 1, 446, 1, 446, 1, 447, 1, 447, 1, 447, 1, 447, 5, 447, 10785, + 8, 447, 10, 447, 12, 447, 10788, 9, 447, 1, 447, 1, 447, 1, 447, 1, 447, + 3, 447, 10794, 8, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, + 1, 450, 1, 450, 1, 450, 1, 450, 5, 450, 10806, 8, 450, 10, 450, 12, 450, + 10809, 9, 450, 1, 450, 1, 450, 1, 450, 1, 450, 3, 450, 10815, 8, 450, 1, + 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, + 451, 1, 451, 3, 451, 10828, 8, 451, 1, 451, 1, 451, 3, 451, 10832, 8, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 10839, 8, 451, 1, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 10849, + 8, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 10856, 8, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 10863, 8, 451, 1, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 10870, 8, 451, 1, 451, 1, 451, + 1, 451, 1, 451, 1, 451, 3, 451, 10877, 8, 451, 1, 451, 1, 451, 1, 451, + 1, 451, 1, 451, 3, 451, 10884, 8, 451, 1, 451, 1, 451, 1, 451, 1, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 10894, 8, 451, 1, 451, 1, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 10904, 8, 451, + 1, 452, 1, 452, 1, 452, 1, 452, 3, 452, 10910, 8, 452, 1, 453, 1, 453, + 1, 453, 1, 453, 1, 454, 1, 454, 1, 455, 1, 455, 1, 455, 1, 455, 3, 455, + 10922, 8, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, 1, 455, + 3, 455, 10931, 8, 455, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 3, 456, + 10938, 8, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, + 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, + 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 1, 456, 3, 456, 10962, 8, 456, + 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, 1, 457, + 1, 457, 3, 457, 10974, 8, 457, 1, 458, 1, 458, 1, 458, 3, 458, 10979, 8, + 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, + 458, 1, 458, 1, 458, 3, 458, 10992, 8, 458, 1, 458, 1, 458, 1, 458, 3, + 458, 10997, 8, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 1, + 458, 3, 458, 11006, 8, 458, 3, 458, 11008, 8, 458, 1, 459, 1, 459, 3, 459, + 11012, 8, 459, 1, 459, 1, 459, 3, 459, 11016, 8, 459, 1, 459, 1, 459, 1, + 459, 1, 459, 3, 459, 11022, 8, 459, 1, 460, 1, 460, 1, 461, 3, 461, 11027, + 8, 461, 1, 461, 1, 461, 3, 461, 11031, 8, 461, 1, 461, 1, 461, 3, 461, + 11035, 8, 461, 1, 461, 1, 461, 1, 461, 3, 461, 11040, 8, 461, 1, 461, 1, + 461, 3, 461, 11044, 8, 461, 1, 461, 1, 461, 1, 461, 3, 461, 11049, 8, 461, + 1, 461, 1, 461, 1, 461, 3, 461, 11054, 8, 461, 1, 462, 1, 462, 1, 462, + 1, 462, 1, 462, 1, 462, 1, 462, 1, 462, 3, 462, 11064, 8, 462, 1, 463, + 1, 463, 1, 463, 4, 463, 11069, 8, 463, 11, 463, 12, 463, 11070, 1, 463, + 1, 463, 3, 463, 11075, 8, 463, 1, 463, 1, 463, 1, 463, 1, 463, 4, 463, + 11081, 8, 463, 11, 463, 12, 463, 11082, 1, 463, 1, 463, 3, 463, 11087, + 8, 463, 1, 463, 1, 463, 3, 463, 11091, 8, 463, 1, 464, 1, 464, 1, 464, + 1, 464, 1, 464, 1, 465, 1, 465, 1, 465, 1, 465, 1, 465, 1, 466, 3, 466, + 11104, 8, 466, 1, 466, 1, 466, 5, 466, 11108, 8, 466, 10, 466, 12, 466, + 11111, 9, 466, 1, 467, 1, 467, 1, 467, 1, 467, 5, 467, 11117, 8, 467, 10, + 467, 12, 467, 11120, 9, 467, 1, 468, 3, 468, 11123, 8, 468, 1, 468, 1, + 468, 1, 468, 1, 468, 1, 468, 3, 468, 11130, 8, 468, 1, 468, 1, 468, 1, + 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, + 468, 1, 468, 3, 468, 11145, 8, 468, 1, 468, 1, 468, 1, 468, 1, 468, 1, + 468, 3, 468, 11152, 8, 468, 1, 469, 1, 469, 1, 470, 1, 470, 1, 471, 1, + 471, 1, 471, 3, 471, 11161, 8, 471, 1, 471, 1, 471, 1, 471, 3, 471, 11166, + 8, 471, 1, 472, 1, 472, 3, 472, 11170, 8, 472, 1, 472, 1, 472, 3, 472, + 11174, 8, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 3, 472, 11181, 8, + 472, 1, 473, 3, 473, 11184, 8, 473, 1, 473, 3, 473, 11187, 8, 473, 1, 473, + 3, 473, 11190, 8, 473, 1, 473, 3, 473, 11193, 8, 473, 1, 473, 3, 473, 11196, + 8, 473, 1, 473, 3, 473, 11199, 8, 473, 1, 474, 1, 474, 1, 474, 1, 475, + 1, 475, 1, 475, 1, 476, 3, 476, 11208, 8, 476, 1, 476, 1, 476, 1, 477, + 3, 477, 11213, 8, 477, 1, 477, 1, 477, 1, 477, 1, 478, 1, 478, 1, 478, + 5, 478, 11221, 8, 478, 10, 478, 12, 478, 11224, 9, 478, 1, 479, 1, 479, + 3, 479, 11228, 8, 479, 1, 480, 1, 480, 1, 480, 1, 480, 3, 480, 11234, 8, + 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 3, 480, 11241, 8, 480, 1, + 480, 1, 480, 3, 480, 11245, 8, 480, 1, 480, 1, 480, 1, 480, 1, 480, 3, + 480, 11251, 8, 480, 1, 480, 1, 480, 1, 480, 3, 480, 11256, 8, 480, 3, 480, + 11258, 8, 480, 1, 481, 3, 481, 11261, 8, 481, 1, 481, 1, 481, 1, 482, 1, + 482, 3, 482, 11267, 8, 482, 1, 482, 3, 482, 11270, 8, 482, 1, 483, 1, 483, + 1, 484, 1, 484, 1, 485, 1, 485, 1, 485, 1, 486, 1, 486, 1, 486, 1, 487, + 1, 487, 1, 487, 1, 487, 1, 488, 1, 488, 1, 488, 1, 489, 1, 489, 1, 489, + 1, 490, 1, 490, 1, 490, 5, 490, 11295, 8, 490, 10, 490, 12, 490, 11298, + 9, 490, 1, 491, 1, 491, 1, 492, 1, 492, 5, 492, 11304, 8, 492, 10, 492, + 12, 492, 11307, 9, 492, 1, 492, 1, 492, 1, 492, 1, 492, 5, 492, 11313, + 8, 492, 10, 492, 12, 492, 11316, 9, 492, 3, 492, 11318, 8, 492, 1, 493, + 1, 493, 3, 493, 11322, 8, 493, 1, 493, 3, 493, 11325, 8, 493, 1, 493, 3, + 493, 11328, 8, 493, 1, 493, 3, 493, 11331, 8, 493, 1, 493, 3, 493, 11334, + 8, 493, 1, 493, 3, 493, 11337, 8, 493, 1, 493, 1, 493, 1, 493, 1, 493, + 1, 493, 1, 493, 1, 493, 3, 493, 11346, 8, 493, 1, 493, 1, 493, 1, 493, + 1, 493, 1, 493, 1, 493, 1, 493, 1, 493, 3, 493, 11356, 8, 493, 1, 493, + 3, 493, 11359, 8, 493, 1, 493, 3, 493, 11362, 8, 493, 1, 493, 1, 493, 1, + 493, 1, 493, 3, 493, 11368, 8, 493, 1, 493, 3, 493, 11371, 8, 493, 1, 493, + 1, 493, 1, 493, 1, 493, 3, 493, 11377, 8, 493, 1, 493, 3, 493, 11380, 8, + 493, 1, 493, 1, 493, 1, 493, 3, 493, 11385, 8, 493, 3, 493, 11387, 8, 493, + 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, 1, 494, + 1, 494, 1, 494, 1, 494, 3, 494, 11401, 8, 494, 1, 495, 1, 495, 1, 495, + 1, 495, 3, 495, 11407, 8, 495, 1, 495, 1, 495, 1, 495, 5, 495, 11412, 8, + 495, 10, 495, 12, 495, 11415, 9, 495, 1, 495, 1, 495, 1, 496, 1, 496, 1, + 496, 5, 496, 11422, 8, 496, 10, 496, 12, 496, 11425, 9, 496, 1, 497, 3, + 497, 11428, 8, 497, 1, 497, 1, 497, 1, 497, 3, 497, 11433, 8, 497, 1, 497, + 1, 497, 1, 498, 1, 498, 3, 498, 11439, 8, 498, 1, 499, 1, 499, 3, 499, + 11443, 8, 499, 1, 500, 3, 500, 11446, 8, 500, 1, 500, 1, 500, 1, 500, 1, + 500, 3, 500, 11452, 8, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 3, + 500, 11459, 8, 500, 3, 500, 11461, 8, 500, 1, 500, 1, 500, 3, 500, 11465, + 8, 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 3, 500, 11472, 8, 500, + 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, + 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 3, 501, 11488, 8, 501, 1, 501, + 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 3, 501, + 11499, 8, 501, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, + 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 1, 502, 3, 502, 11514, 8, 502, + 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 1, 503, 3, 503, + 11524, 8, 503, 1, 504, 1, 504, 1, 504, 3, 504, 11529, 8, 504, 1, 505, 1, + 505, 1, 505, 1, 505, 1, 506, 1, 506, 1, 507, 1, 507, 3, 507, 11539, 8, + 507, 1, 507, 1, 507, 1, 507, 1, 507, 3, 507, 11545, 8, 507, 1, 507, 1, + 507, 5, 507, 11549, 8, 507, 10, 507, 12, 507, 11552, 9, 507, 1, 508, 1, + 508, 1, 508, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, 509, 1, + 509, 1, 509, 3, 509, 11566, 8, 509, 1, 510, 1, 510, 1, 510, 1, 510, 1, + 510, 1, 510, 1, 510, 1, 510, 3, 510, 11576, 8, 510, 1, 510, 3, 510, 11579, + 8, 510, 1, 511, 1, 511, 1, 512, 1, 512, 1, 513, 1, 513, 1, 513, 1, 513, + 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 1, 513, 3, 513, 11596, + 8, 513, 1, 513, 3, 513, 11599, 8, 513, 1, 514, 1, 514, 1, 514, 1, 514, + 1, 514, 1, 514, 1, 514, 1, 514, 5, 514, 11609, 8, 514, 10, 514, 12, 514, + 11612, 9, 514, 1, 515, 1, 515, 1, 515, 1, 516, 1, 516, 1, 516, 3, 516, + 11620, 8, 516, 1, 516, 3, 516, 11623, 8, 516, 1, 516, 3, 516, 11626, 8, + 516, 1, 516, 3, 516, 11629, 8, 516, 1, 516, 3, 516, 11632, 8, 516, 1, 516, + 3, 516, 11635, 8, 516, 1, 516, 3, 516, 11638, 8, 516, 1, 516, 1, 516, 1, + 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, + 517, 1, 517, 1, 517, 1, 517, 5, 517, 11655, 8, 517, 10, 517, 12, 517, 11658, + 9, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, + 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 1, 517, 3, 517, 11674, 8, 517, + 1, 518, 1, 518, 1, 518, 1, 518, 5, 518, 11680, 8, 518, 10, 518, 12, 518, + 11683, 9, 518, 1, 518, 1, 518, 1, 519, 1, 519, 1, 519, 1, 519, 1, 520, + 1, 520, 1, 520, 1, 520, 5, 520, 11695, 8, 520, 10, 520, 12, 520, 11698, + 9, 520, 1, 520, 3, 520, 11701, 8, 520, 1, 520, 3, 520, 11704, 8, 520, 1, + 521, 1, 521, 3, 521, 11708, 8, 521, 1, 522, 1, 522, 1, 522, 1, 522, 1, + 522, 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 3, 523, 11720, 8, 523, 1, + 523, 1, 523, 3, 523, 11724, 8, 523, 1, 524, 1, 524, 3, 524, 11728, 8, 524, + 1, 524, 1, 524, 1, 525, 1, 525, 5, 525, 11734, 8, 525, 10, 525, 12, 525, + 11737, 9, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 3, 525, 11744, 8, + 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 1, 525, 5, 525, 11752, 8, + 525, 10, 525, 12, 525, 11755, 9, 525, 1, 526, 1, 526, 1, 527, 3, 527, 11760, + 8, 527, 1, 527, 1, 527, 1, 528, 1, 528, 1, 529, 1, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 3, 529, 11784, 8, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 1, 529, 3, 529, 11793, 8, 529, + 1, 529, 1, 529, 1, 529, 1, 529, 3, 529, 11799, 8, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 3, 529, 11805, 8, 529, 1, 529, 1, 529, 1, 529, 1, 529, + 3, 529, 11811, 8, 529, 1, 529, 1, 529, 3, 529, 11815, 8, 529, 1, 529, 1, + 529, 1, 529, 1, 529, 1, 529, 3, 529, 11822, 8, 529, 1, 529, 1, 529, 1, + 529, 1, 529, 1, 529, 1, 529, 5, 529, 11830, 8, 529, 10, 529, 12, 529, 11833, + 9, 529, 1, 529, 1, 529, 1, 529, 3, 529, 11838, 8, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 529, 3, 529, 11845, 8, 529, 1, 530, 1, 530, 1, 530, + 1, 531, 1, 531, 1, 531, 3, 531, 11853, 8, 531, 1, 532, 1, 532, 1, 532, + 1, 532, 1, 532, 5, 532, 11860, 8, 532, 10, 532, 12, 532, 11863, 9, 532, + 1, 532, 3, 532, 11866, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 1, 532, 3, 532, 11874, 8, 532, 1, 532, 1, 532, 1, 532, 1, 532, 5, 532, + 11880, 8, 532, 10, 532, 12, 532, 11883, 9, 532, 1, 532, 1, 532, 3, 532, + 11887, 8, 532, 1, 533, 1, 533, 1, 533, 1, 534, 1, 534, 1, 534, 1, 535, + 1, 535, 1, 535, 3, 535, 11898, 8, 535, 1, 535, 3, 535, 11901, 8, 535, 1, + 535, 1, 535, 3, 535, 11905, 8, 535, 1, 536, 1, 536, 1, 536, 1, 536, 1, + 536, 5, 536, 11912, 8, 536, 10, 536, 12, 536, 11915, 9, 536, 1, 537, 1, + 537, 1, 538, 1, 538, 1, 539, 1, 539, 1, 539, 1, 539, 3, 539, 11925, 8, + 539, 1, 539, 1, 539, 3, 539, 11929, 8, 539, 1, 539, 3, 539, 11932, 8, 539, + 1, 539, 1, 539, 3, 539, 11936, 8, 539, 1, 539, 1, 539, 3, 539, 11940, 8, + 539, 1, 539, 3, 539, 11943, 8, 539, 3, 539, 11945, 8, 539, 1, 540, 1, 540, + 1, 540, 0, 2, 886, 1050, 541, 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, 0, 97, 2, 0, 23, 23, 319, 319, 2, 0, + 707, 708, 710, 710, 1, 0, 1078, 1080, 6, 0, 74, 74, 194, 194, 407, 407, + 565, 565, 581, 581, 1032, 1032, 3, 0, 407, 407, 886, 886, 1062, 1062, 2, + 0, 185, 185, 714, 714, 2, 0, 283, 283, 981, 981, 3, 0, 670, 670, 773, 773, + 981, 981, 6, 0, 10, 10, 568, 568, 636, 636, 771, 771, 877, 877, 985, 985, + 8, 0, 68, 68, 108, 108, 111, 111, 230, 230, 354, 354, 508, 508, 649, 649, + 1038, 1038, 2, 0, 703, 703, 870, 870, 3, 0, 161, 161, 755, 755, 1011, 1011, + 4, 0, 47, 47, 49, 49, 161, 161, 258, 258, 4, 0, 161, 161, 209, 209, 222, + 222, 467, 467, 4, 0, 619, 619, 671, 671, 703, 703, 870, 870, 2, 0, 161, + 161, 769, 769, 2, 0, 689, 689, 697, 697, 8, 0, 161, 161, 165, 165, 179, + 179, 357, 357, 464, 464, 689, 689, 697, 697, 769, 769, 2, 0, 161, 161, + 258, 258, 5, 0, 205, 205, 486, 486, 498, 498, 1014, 1014, 1037, 1037, 3, + 0, 516, 516, 870, 870, 872, 872, 2, 0, 239, 239, 257, 257, 4, 0, 84, 84, + 204, 204, 546, 546, 600, 600, 3, 0, 239, 239, 257, 257, 259, 259, 2, 0, + 377, 377, 508, 508, 2, 0, 258, 258, 296, 296, 3, 0, 161, 161, 497, 497, + 876, 876, 2, 0, 783, 783, 974, 974, 2, 0, 14, 14, 681, 681, 3, 0, 161, + 161, 258, 258, 853, 853, 2, 0, 66, 66, 363, 363, 2, 0, 227, 227, 374, 374, + 3, 0, 330, 330, 583, 583, 797, 797, 2, 0, 518, 518, 994, 994, 2, 0, 510, + 510, 677, 677, 3, 0, 273, 273, 340, 340, 867, 867, 2, 0, 38, 38, 483, 483, + 2, 0, 14, 14, 249, 249, 3, 0, 109, 109, 272, 272, 826, 826, 3, 0, 207, + 207, 757, 757, 880, 880, 2, 0, 59, 59, 93, 93, 4, 0, 62, 62, 230, 230, + 354, 354, 508, 508, 2, 0, 376, 376, 1009, 1009, 6, 0, 74, 75, 194, 195, + 407, 408, 565, 566, 581, 582, 1032, 1033, 2, 0, 115, 115, 575, 575, 3, + 0, 88, 88, 338, 338, 548, 548, 3, 0, 1, 1, 339, 339, 547, 547, 2, 0, 446, + 446, 881, 882, 8, 0, 62, 63, 108, 108, 111, 111, 230, 230, 354, 354, 508, + 508, 649, 649, 1038, 1038, 3, 0, 92, 92, 358, 358, 993, 993, 2, 0, 310, + 310, 944, 944, 1, 0, 893, 894, 2, 0, 345, 345, 438, 438, 50, 0, 4, 4, 31, + 31, 34, 34, 64, 65, 100, 101, 138, 148, 209, 209, 215, 216, 222, 222, 260, + 260, 263, 263, 271, 271, 276, 277, 293, 293, 341, 342, 387, 387, 403, 405, + 409, 410, 442, 442, 466, 467, 480, 480, 488, 488, 497, 497, 596, 596, 603, + 603, 616, 617, 644, 644, 646, 646, 691, 692, 728, 728, 751, 751, 789, 789, + 798, 798, 821, 821, 835, 836, 860, 860, 873, 873, 905, 905, 907, 907, 909, + 909, 911, 913, 915, 915, 918, 918, 920, 921, 932, 933, 952, 952, 975, 975, + 988, 989, 991, 991, 1015, 1016, 5, 0, 419, 419, 470, 470, 808, 808, 1027, + 1030, 1034, 1036, 11, 0, 208, 208, 395, 395, 719, 719, 758, 758, 823, 823, + 858, 858, 883, 883, 892, 892, 986, 986, 1006, 1006, 1012, 1012, 4, 0, 44, + 44, 512, 512, 770, 770, 849, 849, 2, 0, 116, 116, 700, 700, 2, 0, 23, 23, + 508, 508, 1, 0, 235, 236, 2, 0, 158, 158, 822, 822, 2, 0, 322, 322, 380, + 380, 4, 0, 207, 207, 757, 757, 891, 891, 1011, 1011, 14, 0, 59, 59, 151, + 151, 187, 187, 331, 331, 364, 364, 393, 393, 673, 673, 721, 721, 822, 822, + 893, 893, 904, 904, 954, 954, 984, 984, 1041, 1041, 23, 0, 10, 10, 229, + 229, 382, 382, 402, 402, 438, 438, 492, 492, 563, 563, 568, 568, 630, 630, + 636, 636, 702, 702, 718, 718, 729, 729, 771, 771, 813, 813, 833, 833, 877, + 877, 887, 887, 918, 918, 985, 985, 998, 998, 1004, 1004, 1011, 1011, 10, + 0, 73, 73, 188, 188, 199, 199, 201, 201, 365, 365, 448, 448, 474, 474, + 868, 868, 923, 923, 979, 979, 3, 0, 154, 154, 166, 166, 168, 168, 2, 0, + 366, 366, 527, 527, 2, 0, 924, 924, 1046, 1046, 1, 0, 866, 867, 3, 0, 210, + 210, 900, 900, 916, 916, 3, 0, 211, 211, 901, 901, 917, 917, 1, 0, 1117, + 1118, 1, 0, 1114, 1116, 2, 0, 1098, 1098, 1117, 1118, 3, 0, 40, 40, 511, + 511, 564, 564, 2, 0, 373, 373, 430, 430, 3, 0, 449, 449, 732, 732, 940, + 940, 3, 0, 525, 525, 1048, 1048, 1056, 1056, 2, 0, 57, 57, 235, 235, 1, + 0, 427, 428, 3, 0, 234, 234, 648, 648, 729, 729, 1, 0, 1085, 1086, 2, 0, + 280, 280, 477, 477, 2, 0, 23, 23, 245, 245, 3, 0, 107, 107, 539, 539, 1040, + 1040, 3, 0, 330, 330, 426, 426, 716, 716, 2, 0, 319, 319, 420, 420, 2, + 0, 95, 95, 723, 723, 2, 0, 103, 103, 878, 878, 2, 0, 683, 683, 772, 772, + 2, 0, 752, 752, 884, 884, 1, 0, 1090, 1096, 3, 0, 23, 23, 43, 43, 811, + 811, 2, 0, 723, 723, 727, 727, 2, 0, 319, 319, 505, 505, 80, 0, 1, 8, 10, + 22, 24, 37, 39, 39, 41, 42, 44, 55, 57, 91, 93, 95, 97, 109, 112, 116, + 118, 119, 121, 130, 132, 156, 158, 170, 173, 173, 175, 189, 191, 192, 194, + 197, 203, 206, 208, 231, 233, 244, 246, 248, 250, 252, 254, 284, 286, 300, + 302, 309, 311, 321, 323, 328, 331, 347, 349, 349, 351, 354, 356, 371, 374, + 379, 382, 387, 389, 389, 391, 395, 399, 405, 407, 423, 425, 425, 427, 429, + 431, 492, 494, 510, 512, 531, 533, 541, 543, 552, 554, 563, 565, 566, 568, + 568, 570, 639, 641, 713, 715, 715, 718, 722, 724, 726, 728, 730, 732, 733, + 735, 736, 751, 751, 753, 756, 758, 772, 774, 782, 784, 810, 812, 827, 829, + 879, 881, 883, 885, 896, 898, 904, 906, 921, 923, 937, 939, 942, 945, 948, + 950, 964, 967, 976, 978, 991, 994, 998, 1000, 1004, 1006, 1017, 1021, 1026, + 1030, 1048, 1051, 1056, 1058, 1068, 13800, 0, 1093, 1, 0, 0, 0, 2, 1097, + 1, 0, 0, 0, 4, 1105, 1, 0, 0, 0, 6, 1111, 1, 0, 0, 0, 8, 1119, 1, 0, 0, + 0, 10, 1121, 1, 0, 0, 0, 12, 1166, 1, 0, 0, 0, 14, 1168, 1, 0, 0, 0, 16, + 1179, 1, 0, 0, 0, 18, 1194, 1, 0, 0, 0, 20, 1196, 1, 0, 0, 0, 22, 1222, + 1, 0, 0, 0, 24, 1244, 1, 0, 0, 0, 26, 1246, 1, 0, 0, 0, 28, 1258, 1, 0, + 0, 0, 30, 1287, 1, 0, 0, 0, 32, 1289, 1, 0, 0, 0, 34, 1304, 1, 0, 0, 0, + 36, 1339, 1, 0, 0, 0, 38, 1394, 1, 0, 0, 0, 40, 1396, 1, 0, 0, 0, 42, 1398, + 1, 0, 0, 0, 44, 1411, 1, 0, 0, 0, 46, 1420, 1, 0, 0, 0, 48, 1424, 1, 0, + 0, 0, 50, 1449, 1, 0, 0, 0, 52, 1451, 1, 0, 0, 0, 54, 1503, 1, 0, 0, 0, + 56, 1505, 1, 0, 0, 0, 58, 1560, 1, 0, 0, 0, 60, 1562, 1, 0, 0, 0, 62, 1566, + 1, 0, 0, 0, 64, 1573, 1, 0, 0, 0, 66, 1577, 1, 0, 0, 0, 68, 1586, 1, 0, + 0, 0, 70, 1623, 1, 0, 0, 0, 72, 1731, 1, 0, 0, 0, 74, 1783, 1, 0, 0, 0, + 76, 1785, 1, 0, 0, 0, 78, 1802, 1, 0, 0, 0, 80, 1804, 1, 0, 0, 0, 82, 1844, + 1, 0, 0, 0, 84, 1846, 1, 0, 0, 0, 86, 1869, 1, 0, 0, 0, 88, 1871, 1, 0, + 0, 0, 90, 1897, 1, 0, 0, 0, 92, 1899, 1, 0, 0, 0, 94, 1911, 1, 0, 0, 0, + 96, 1913, 1, 0, 0, 0, 98, 1915, 1, 0, 0, 0, 100, 1923, 1, 0, 0, 0, 102, + 1927, 1, 0, 0, 0, 104, 1931, 1, 0, 0, 0, 106, 1954, 1, 0, 0, 0, 108, 1962, + 1, 0, 0, 0, 110, 2068, 1, 0, 0, 0, 112, 2099, 1, 0, 0, 0, 114, 2109, 1, + 0, 0, 0, 116, 2141, 1, 0, 0, 0, 118, 2143, 1, 0, 0, 0, 120, 2148, 1, 0, + 0, 0, 122, 2171, 1, 0, 0, 0, 124, 2213, 1, 0, 0, 0, 126, 2257, 1, 0, 0, + 0, 128, 2284, 1, 0, 0, 0, 130, 2286, 1, 0, 0, 0, 132, 2342, 1, 0, 0, 0, + 134, 2437, 1, 0, 0, 0, 136, 2439, 1, 0, 0, 0, 138, 2443, 1, 0, 0, 0, 140, + 2447, 1, 0, 0, 0, 142, 2478, 1, 0, 0, 0, 144, 2487, 1, 0, 0, 0, 146, 2489, + 1, 0, 0, 0, 148, 2572, 1, 0, 0, 0, 150, 2574, 1, 0, 0, 0, 152, 2576, 1, + 0, 0, 0, 154, 2700, 1, 0, 0, 0, 156, 2702, 1, 0, 0, 0, 158, 2704, 1, 0, + 0, 0, 160, 2712, 1, 0, 0, 0, 162, 2825, 1, 0, 0, 0, 164, 2827, 1, 0, 0, + 0, 166, 2831, 1, 0, 0, 0, 168, 2835, 1, 0, 0, 0, 170, 2843, 1, 0, 0, 0, + 172, 2851, 1, 0, 0, 0, 174, 3013, 1, 0, 0, 0, 176, 3043, 1, 0, 0, 0, 178, + 3116, 1, 0, 0, 0, 180, 3118, 1, 0, 0, 0, 182, 3130, 1, 0, 0, 0, 184, 3171, + 1, 0, 0, 0, 186, 3173, 1, 0, 0, 0, 188, 3204, 1, 0, 0, 0, 190, 3269, 1, + 0, 0, 0, 192, 3331, 1, 0, 0, 0, 194, 3391, 1, 0, 0, 0, 196, 3579, 1, 0, + 0, 0, 198, 3581, 1, 0, 0, 0, 200, 3585, 1, 0, 0, 0, 202, 3589, 1, 0, 0, + 0, 204, 3602, 1, 0, 0, 0, 206, 3608, 1, 0, 0, 0, 208, 3695, 1, 0, 0, 0, + 210, 3733, 1, 0, 0, 0, 212, 3819, 1, 0, 0, 0, 214, 3821, 1, 0, 0, 0, 216, + 3870, 1, 0, 0, 0, 218, 4010, 1, 0, 0, 0, 220, 4020, 1, 0, 0, 0, 222, 4161, + 1, 0, 0, 0, 224, 4163, 1, 0, 0, 0, 226, 4276, 1, 0, 0, 0, 228, 4335, 1, + 0, 0, 0, 230, 4337, 1, 0, 0, 0, 232, 4386, 1, 0, 0, 0, 234, 4403, 1, 0, + 0, 0, 236, 4437, 1, 0, 0, 0, 238, 4527, 1, 0, 0, 0, 240, 4599, 1, 0, 0, + 0, 242, 4667, 1, 0, 0, 0, 244, 4704, 1, 0, 0, 0, 246, 4881, 1, 0, 0, 0, + 248, 4905, 1, 0, 0, 0, 250, 5073, 1, 0, 0, 0, 252, 5076, 1, 0, 0, 0, 254, + 5142, 1, 0, 0, 0, 256, 5166, 1, 0, 0, 0, 258, 5210, 1, 0, 0, 0, 260, 5240, + 1, 0, 0, 0, 262, 5242, 1, 0, 0, 0, 264, 5317, 1, 0, 0, 0, 266, 5319, 1, + 0, 0, 0, 268, 5328, 1, 0, 0, 0, 270, 5362, 1, 0, 0, 0, 272, 5365, 1, 0, + 0, 0, 274, 5370, 1, 0, 0, 0, 276, 5374, 1, 0, 0, 0, 278, 5501, 1, 0, 0, + 0, 280, 5503, 1, 0, 0, 0, 282, 5679, 1, 0, 0, 0, 284, 5681, 1, 0, 0, 0, + 286, 5683, 1, 0, 0, 0, 288, 5743, 1, 0, 0, 0, 290, 5779, 1, 0, 0, 0, 292, + 5849, 1, 0, 0, 0, 294, 5887, 1, 0, 0, 0, 296, 5926, 1, 0, 0, 0, 298, 5964, + 1, 0, 0, 0, 300, 5966, 1, 0, 0, 0, 302, 5969, 1, 0, 0, 0, 304, 5983, 1, + 0, 0, 0, 306, 6034, 1, 0, 0, 0, 308, 6036, 1, 0, 0, 0, 310, 6079, 1, 0, + 0, 0, 312, 6107, 1, 0, 0, 0, 314, 6109, 1, 0, 0, 0, 316, 6225, 1, 0, 0, + 0, 318, 6274, 1, 0, 0, 0, 320, 6276, 1, 0, 0, 0, 322, 6298, 1, 0, 0, 0, + 324, 6332, 1, 0, 0, 0, 326, 6351, 1, 0, 0, 0, 328, 6370, 1, 0, 0, 0, 330, + 6372, 1, 0, 0, 0, 332, 6376, 1, 0, 0, 0, 334, 6378, 1, 0, 0, 0, 336, 6382, + 1, 0, 0, 0, 338, 6629, 1, 0, 0, 0, 340, 6631, 1, 0, 0, 0, 342, 6641, 1, + 0, 0, 0, 344, 6649, 1, 0, 0, 0, 346, 6657, 1, 0, 0, 0, 348, 6748, 1, 0, + 0, 0, 350, 6750, 1, 0, 0, 0, 352, 6752, 1, 0, 0, 0, 354, 6776, 1, 0, 0, + 0, 356, 6779, 1, 0, 0, 0, 358, 6784, 1, 0, 0, 0, 360, 6915, 1, 0, 0, 0, + 362, 6917, 1, 0, 0, 0, 364, 6936, 1, 0, 0, 0, 366, 6964, 1, 0, 0, 0, 368, + 6968, 1, 0, 0, 0, 370, 6972, 1, 0, 0, 0, 372, 7006, 1, 0, 0, 0, 374, 7048, + 1, 0, 0, 0, 376, 7076, 1, 0, 0, 0, 378, 7121, 1, 0, 0, 0, 380, 7123, 1, + 0, 0, 0, 382, 7158, 1, 0, 0, 0, 384, 7160, 1, 0, 0, 0, 386, 7166, 1, 0, + 0, 0, 388, 7286, 1, 0, 0, 0, 390, 7377, 1, 0, 0, 0, 392, 7379, 1, 0, 0, + 0, 394, 7417, 1, 0, 0, 0, 396, 7453, 1, 0, 0, 0, 398, 7482, 1, 0, 0, 0, + 400, 7521, 1, 0, 0, 0, 402, 7615, 1, 0, 0, 0, 404, 7744, 1, 0, 0, 0, 406, + 7746, 1, 0, 0, 0, 408, 7816, 1, 0, 0, 0, 410, 7846, 1, 0, 0, 0, 412, 7850, + 1, 0, 0, 0, 414, 7852, 1, 0, 0, 0, 416, 7861, 1, 0, 0, 0, 418, 7870, 1, + 0, 0, 0, 420, 7891, 1, 0, 0, 0, 422, 7914, 1, 0, 0, 0, 424, 7923, 1, 0, + 0, 0, 426, 8067, 1, 0, 0, 0, 428, 8101, 1, 0, 0, 0, 430, 8111, 1, 0, 0, + 0, 432, 8113, 1, 0, 0, 0, 434, 8117, 1, 0, 0, 0, 436, 8121, 1, 0, 0, 0, + 438, 8125, 1, 0, 0, 0, 440, 8148, 1, 0, 0, 0, 442, 8152, 1, 0, 0, 0, 444, + 8156, 1, 0, 0, 0, 446, 8160, 1, 0, 0, 0, 448, 8253, 1, 0, 0, 0, 450, 8255, + 1, 0, 0, 0, 452, 8257, 1, 0, 0, 0, 454, 8261, 1, 0, 0, 0, 456, 8265, 1, + 0, 0, 0, 458, 8269, 1, 0, 0, 0, 460, 8324, 1, 0, 0, 0, 462, 8428, 1, 0, + 0, 0, 464, 8450, 1, 0, 0, 0, 466, 8463, 1, 0, 0, 0, 468, 8465, 1, 0, 0, + 0, 470, 8469, 1, 0, 0, 0, 472, 8502, 1, 0, 0, 0, 474, 8505, 1, 0, 0, 0, + 476, 8509, 1, 0, 0, 0, 478, 8513, 1, 0, 0, 0, 480, 8517, 1, 0, 0, 0, 482, + 8632, 1, 0, 0, 0, 484, 8634, 1, 0, 0, 0, 486, 8644, 1, 0, 0, 0, 488, 8647, + 1, 0, 0, 0, 490, 8662, 1, 0, 0, 0, 492, 8680, 1, 0, 0, 0, 494, 8684, 1, + 0, 0, 0, 496, 8689, 1, 0, 0, 0, 498, 8698, 1, 0, 0, 0, 500, 8701, 1, 0, + 0, 0, 502, 8720, 1, 0, 0, 0, 504, 8722, 1, 0, 0, 0, 506, 8727, 1, 0, 0, + 0, 508, 8754, 1, 0, 0, 0, 510, 8776, 1, 0, 0, 0, 512, 8778, 1, 0, 0, 0, + 514, 8786, 1, 0, 0, 0, 516, 8849, 1, 0, 0, 0, 518, 8923, 1, 0, 0, 0, 520, + 8925, 1, 0, 0, 0, 522, 8927, 1, 0, 0, 0, 524, 8935, 1, 0, 0, 0, 526, 8943, + 1, 0, 0, 0, 528, 8947, 1, 0, 0, 0, 530, 9019, 1, 0, 0, 0, 532, 9021, 1, + 0, 0, 0, 534, 9029, 1, 0, 0, 0, 536, 9047, 1, 0, 0, 0, 538, 9051, 1, 0, + 0, 0, 540, 9093, 1, 0, 0, 0, 542, 9153, 1, 0, 0, 0, 544, 9167, 1, 0, 0, + 0, 546, 9169, 1, 0, 0, 0, 548, 9202, 1, 0, 0, 0, 550, 9204, 1, 0, 0, 0, + 552, 9238, 1, 0, 0, 0, 554, 9240, 1, 0, 0, 0, 556, 9247, 1, 0, 0, 0, 558, + 9251, 1, 0, 0, 0, 560, 9258, 1, 0, 0, 0, 562, 9267, 1, 0, 0, 0, 564, 9275, + 1, 0, 0, 0, 566, 9285, 1, 0, 0, 0, 568, 9293, 1, 0, 0, 0, 570, 9301, 1, + 0, 0, 0, 572, 9309, 1, 0, 0, 0, 574, 9319, 1, 0, 0, 0, 576, 9324, 1, 0, + 0, 0, 578, 9329, 1, 0, 0, 0, 580, 9337, 1, 0, 0, 0, 582, 9345, 1, 0, 0, + 0, 584, 9352, 1, 0, 0, 0, 586, 9360, 1, 0, 0, 0, 588, 9368, 1, 0, 0, 0, + 590, 9373, 1, 0, 0, 0, 592, 9380, 1, 0, 0, 0, 594, 9389, 1, 0, 0, 0, 596, + 9398, 1, 0, 0, 0, 598, 9407, 1, 0, 0, 0, 600, 9415, 1, 0, 0, 0, 602, 9419, + 1, 0, 0, 0, 604, 9426, 1, 0, 0, 0, 606, 9433, 1, 0, 0, 0, 608, 9442, 1, + 0, 0, 0, 610, 9449, 1, 0, 0, 0, 612, 9456, 1, 0, 0, 0, 614, 9463, 1, 0, + 0, 0, 616, 9470, 1, 0, 0, 0, 618, 9477, 1, 0, 0, 0, 620, 9479, 1, 0, 0, + 0, 622, 9490, 1, 0, 0, 0, 624, 9492, 1, 0, 0, 0, 626, 9496, 1, 0, 0, 0, + 628, 9501, 1, 0, 0, 0, 630, 9505, 1, 0, 0, 0, 632, 9509, 1, 0, 0, 0, 634, + 9518, 1, 0, 0, 0, 636, 9520, 1, 0, 0, 0, 638, 9524, 1, 0, 0, 0, 640, 9528, + 1, 0, 0, 0, 642, 9539, 1, 0, 0, 0, 644, 9544, 1, 0, 0, 0, 646, 9548, 1, + 0, 0, 0, 648, 9552, 1, 0, 0, 0, 650, 9555, 1, 0, 0, 0, 652, 9558, 1, 0, + 0, 0, 654, 9562, 1, 0, 0, 0, 656, 9565, 1, 0, 0, 0, 658, 9594, 1, 0, 0, + 0, 660, 9596, 1, 0, 0, 0, 662, 9600, 1, 0, 0, 0, 664, 9604, 1, 0, 0, 0, + 666, 9609, 1, 0, 0, 0, 668, 9620, 1, 0, 0, 0, 670, 9625, 1, 0, 0, 0, 672, + 9630, 1, 0, 0, 0, 674, 9637, 1, 0, 0, 0, 676, 9642, 1, 0, 0, 0, 678, 9647, + 1, 0, 0, 0, 680, 9652, 1, 0, 0, 0, 682, 9656, 1, 0, 0, 0, 684, 9661, 1, + 0, 0, 0, 686, 9669, 1, 0, 0, 0, 688, 9675, 1, 0, 0, 0, 690, 9679, 1, 0, + 0, 0, 692, 9685, 1, 0, 0, 0, 694, 9689, 1, 0, 0, 0, 696, 9694, 1, 0, 0, + 0, 698, 9698, 1, 0, 0, 0, 700, 9702, 1, 0, 0, 0, 702, 9706, 1, 0, 0, 0, + 704, 9714, 1, 0, 0, 0, 706, 9718, 1, 0, 0, 0, 708, 9722, 1, 0, 0, 0, 710, + 9726, 1, 0, 0, 0, 712, 9730, 1, 0, 0, 0, 714, 9785, 1, 0, 0, 0, 716, 9787, + 1, 0, 0, 0, 718, 9815, 1, 0, 0, 0, 720, 9844, 1, 0, 0, 0, 722, 9849, 1, + 0, 0, 0, 724, 9853, 1, 0, 0, 0, 726, 9859, 1, 0, 0, 0, 728, 9876, 1, 0, + 0, 0, 730, 9883, 1, 0, 0, 0, 732, 9906, 1, 0, 0, 0, 734, 9908, 1, 0, 0, + 0, 736, 9914, 1, 0, 0, 0, 738, 9942, 1, 0, 0, 0, 740, 9973, 1, 0, 0, 0, + 742, 9981, 1, 0, 0, 0, 744, 10000, 1, 0, 0, 0, 746, 10018, 1, 0, 0, 0, + 748, 10041, 1, 0, 0, 0, 750, 10064, 1, 0, 0, 0, 752, 10066, 1, 0, 0, 0, + 754, 10074, 1, 0, 0, 0, 756, 10080, 1, 0, 0, 0, 758, 10086, 1, 0, 0, 0, + 760, 10095, 1, 0, 0, 0, 762, 10106, 1, 0, 0, 0, 764, 10121, 1, 0, 0, 0, + 766, 10130, 1, 0, 0, 0, 768, 10134, 1, 0, 0, 0, 770, 10142, 1, 0, 0, 0, + 772, 10148, 1, 0, 0, 0, 774, 10150, 1, 0, 0, 0, 776, 10172, 1, 0, 0, 0, + 778, 10180, 1, 0, 0, 0, 780, 10189, 1, 0, 0, 0, 782, 10197, 1, 0, 0, 0, + 784, 10202, 1, 0, 0, 0, 786, 10208, 1, 0, 0, 0, 788, 10222, 1, 0, 0, 0, + 790, 10230, 1, 0, 0, 0, 792, 10236, 1, 0, 0, 0, 794, 10241, 1, 0, 0, 0, + 796, 10251, 1, 0, 0, 0, 798, 10278, 1, 0, 0, 0, 800, 10286, 1, 0, 0, 0, + 802, 10290, 1, 0, 0, 0, 804, 10295, 1, 0, 0, 0, 806, 10302, 1, 0, 0, 0, + 808, 10309, 1, 0, 0, 0, 810, 10317, 1, 0, 0, 0, 812, 10325, 1, 0, 0, 0, + 814, 10333, 1, 0, 0, 0, 816, 10349, 1, 0, 0, 0, 818, 10379, 1, 0, 0, 0, + 820, 10385, 1, 0, 0, 0, 822, 10394, 1, 0, 0, 0, 824, 10415, 1, 0, 0, 0, + 826, 10420, 1, 0, 0, 0, 828, 10450, 1, 0, 0, 0, 830, 10455, 1, 0, 0, 0, + 832, 10458, 1, 0, 0, 0, 834, 10465, 1, 0, 0, 0, 836, 10479, 1, 0, 0, 0, + 838, 10481, 1, 0, 0, 0, 840, 10489, 1, 0, 0, 0, 842, 10491, 1, 0, 0, 0, + 844, 10493, 1, 0, 0, 0, 846, 10495, 1, 0, 0, 0, 848, 10497, 1, 0, 0, 0, + 850, 10499, 1, 0, 0, 0, 852, 10501, 1, 0, 0, 0, 854, 10503, 1, 0, 0, 0, + 856, 10523, 1, 0, 0, 0, 858, 10525, 1, 0, 0, 0, 860, 10527, 1, 0, 0, 0, + 862, 10529, 1, 0, 0, 0, 864, 10531, 1, 0, 0, 0, 866, 10540, 1, 0, 0, 0, + 868, 10547, 1, 0, 0, 0, 870, 10552, 1, 0, 0, 0, 872, 10554, 1, 0, 0, 0, + 874, 10558, 1, 0, 0, 0, 876, 10560, 1, 0, 0, 0, 878, 10579, 1, 0, 0, 0, + 880, 10581, 1, 0, 0, 0, 882, 10583, 1, 0, 0, 0, 884, 10591, 1, 0, 0, 0, + 886, 10662, 1, 0, 0, 0, 888, 10752, 1, 0, 0, 0, 890, 10761, 1, 0, 0, 0, + 892, 10773, 1, 0, 0, 0, 894, 10793, 1, 0, 0, 0, 896, 10795, 1, 0, 0, 0, + 898, 10799, 1, 0, 0, 0, 900, 10814, 1, 0, 0, 0, 902, 10903, 1, 0, 0, 0, + 904, 10909, 1, 0, 0, 0, 906, 10911, 1, 0, 0, 0, 908, 10915, 1, 0, 0, 0, + 910, 10930, 1, 0, 0, 0, 912, 10961, 1, 0, 0, 0, 914, 10973, 1, 0, 0, 0, + 916, 11007, 1, 0, 0, 0, 918, 11021, 1, 0, 0, 0, 920, 11023, 1, 0, 0, 0, + 922, 11053, 1, 0, 0, 0, 924, 11063, 1, 0, 0, 0, 926, 11090, 1, 0, 0, 0, + 928, 11092, 1, 0, 0, 0, 930, 11097, 1, 0, 0, 0, 932, 11103, 1, 0, 0, 0, + 934, 11112, 1, 0, 0, 0, 936, 11151, 1, 0, 0, 0, 938, 11153, 1, 0, 0, 0, + 940, 11155, 1, 0, 0, 0, 942, 11165, 1, 0, 0, 0, 944, 11180, 1, 0, 0, 0, + 946, 11183, 1, 0, 0, 0, 948, 11200, 1, 0, 0, 0, 950, 11203, 1, 0, 0, 0, + 952, 11207, 1, 0, 0, 0, 954, 11212, 1, 0, 0, 0, 956, 11217, 1, 0, 0, 0, + 958, 11227, 1, 0, 0, 0, 960, 11257, 1, 0, 0, 0, 962, 11260, 1, 0, 0, 0, + 964, 11266, 1, 0, 0, 0, 966, 11271, 1, 0, 0, 0, 968, 11273, 1, 0, 0, 0, + 970, 11275, 1, 0, 0, 0, 972, 11278, 1, 0, 0, 0, 974, 11281, 1, 0, 0, 0, + 976, 11285, 1, 0, 0, 0, 978, 11288, 1, 0, 0, 0, 980, 11291, 1, 0, 0, 0, + 982, 11299, 1, 0, 0, 0, 984, 11317, 1, 0, 0, 0, 986, 11386, 1, 0, 0, 0, + 988, 11400, 1, 0, 0, 0, 990, 11402, 1, 0, 0, 0, 992, 11418, 1, 0, 0, 0, + 994, 11427, 1, 0, 0, 0, 996, 11436, 1, 0, 0, 0, 998, 11442, 1, 0, 0, 0, + 1000, 11471, 1, 0, 0, 0, 1002, 11498, 1, 0, 0, 0, 1004, 11513, 1, 0, 0, + 0, 1006, 11515, 1, 0, 0, 0, 1008, 11528, 1, 0, 0, 0, 1010, 11530, 1, 0, + 0, 0, 1012, 11534, 1, 0, 0, 0, 1014, 11536, 1, 0, 0, 0, 1016, 11553, 1, + 0, 0, 0, 1018, 11565, 1, 0, 0, 0, 1020, 11575, 1, 0, 0, 0, 1022, 11580, + 1, 0, 0, 0, 1024, 11582, 1, 0, 0, 0, 1026, 11584, 1, 0, 0, 0, 1028, 11600, + 1, 0, 0, 0, 1030, 11613, 1, 0, 0, 0, 1032, 11616, 1, 0, 0, 0, 1034, 11673, + 1, 0, 0, 0, 1036, 11675, 1, 0, 0, 0, 1038, 11686, 1, 0, 0, 0, 1040, 11690, + 1, 0, 0, 0, 1042, 11707, 1, 0, 0, 0, 1044, 11709, 1, 0, 0, 0, 1046, 11714, + 1, 0, 0, 0, 1048, 11725, 1, 0, 0, 0, 1050, 11731, 1, 0, 0, 0, 1052, 11756, + 1, 0, 0, 0, 1054, 11759, 1, 0, 0, 0, 1056, 11763, 1, 0, 0, 0, 1058, 11844, + 1, 0, 0, 0, 1060, 11846, 1, 0, 0, 0, 1062, 11852, 1, 0, 0, 0, 1064, 11886, + 1, 0, 0, 0, 1066, 11888, 1, 0, 0, 0, 1068, 11891, 1, 0, 0, 0, 1070, 11897, + 1, 0, 0, 0, 1072, 11906, 1, 0, 0, 0, 1074, 11916, 1, 0, 0, 0, 1076, 11918, + 1, 0, 0, 0, 1078, 11944, 1, 0, 0, 0, 1080, 11946, 1, 0, 0, 0, 1082, 1087, + 3, 2, 1, 0, 1083, 1084, 5, 1111, 0, 0, 1084, 1086, 3, 2, 1, 0, 1085, 1083, + 1, 0, 0, 0, 1086, 1089, 1, 0, 0, 0, 1087, 1085, 1, 0, 0, 0, 1087, 1088, + 1, 0, 0, 0, 1088, 1091, 1, 0, 0, 0, 1089, 1087, 1, 0, 0, 0, 1090, 1092, + 5, 1111, 0, 0, 1091, 1090, 1, 0, 0, 0, 1091, 1092, 1, 0, 0, 0, 1092, 1094, + 1, 0, 0, 0, 1093, 1082, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, 1095, + 1, 0, 0, 0, 1095, 1096, 5, 0, 0, 1, 1096, 1, 1, 0, 0, 0, 1097, 1098, 3, + 4, 2, 0, 1098, 3, 1, 0, 0, 0, 1099, 1106, 3, 6, 3, 0, 1100, 1106, 3, 8, + 4, 0, 1101, 1106, 3, 714, 357, 0, 1102, 1106, 3, 634, 317, 0, 1103, 1106, + 3, 658, 329, 0, 1104, 1106, 3, 36, 18, 0, 1105, 1099, 1, 0, 0, 0, 1105, + 1100, 1, 0, 0, 0, 1105, 1101, 1, 0, 0, 0, 1105, 1102, 1, 0, 0, 0, 1105, + 1103, 1, 0, 0, 0, 1105, 1104, 1, 0, 0, 0, 1106, 5, 1, 0, 0, 0, 1107, 1112, + 3, 124, 62, 0, 1108, 1112, 3, 306, 153, 0, 1109, 1112, 3, 552, 276, 0, + 1110, 1112, 3, 622, 311, 0, 1111, 1107, 1, 0, 0, 0, 1111, 1108, 1, 0, 0, + 0, 1111, 1109, 1, 0, 0, 0, 1111, 1110, 1, 0, 0, 0, 1112, 7, 1, 0, 0, 0, + 1113, 1120, 3, 932, 466, 0, 1114, 1120, 3, 10, 5, 0, 1115, 1120, 3, 12, + 6, 0, 1116, 1120, 3, 28, 14, 0, 1117, 1120, 3, 32, 16, 0, 1118, 1120, 3, + 20, 10, 0, 1119, 1113, 1, 0, 0, 0, 1119, 1114, 1, 0, 0, 0, 1119, 1115, + 1, 0, 0, 0, 1119, 1116, 1, 0, 0, 0, 1119, 1117, 1, 0, 0, 0, 1119, 1118, + 1, 0, 0, 0, 1120, 9, 1, 0, 0, 0, 1121, 1123, 5, 390, 0, 0, 1122, 1124, + 5, 574, 0, 0, 1123, 1122, 1, 0, 0, 0, 1123, 1124, 1, 0, 0, 0, 1124, 1125, + 1, 0, 0, 0, 1125, 1126, 5, 397, 0, 0, 1126, 1131, 3, 878, 439, 0, 1127, + 1128, 5, 1104, 0, 0, 1128, 1129, 3, 876, 438, 0, 1129, 1130, 5, 1105, 0, + 0, 1130, 1132, 1, 0, 0, 0, 1131, 1127, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, + 0, 1132, 1135, 1, 0, 0, 0, 1133, 1136, 3, 34, 17, 0, 1134, 1136, 3, 942, + 471, 0, 1135, 1133, 1, 0, 0, 0, 1135, 1134, 1, 0, 0, 0, 1136, 11, 1, 0, + 0, 0, 1137, 1139, 5, 390, 0, 0, 1138, 1140, 5, 574, 0, 0, 1139, 1138, 1, + 0, 0, 0, 1139, 1140, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 1142, 5, + 23, 0, 0, 1142, 1167, 3, 14, 7, 0, 1143, 1145, 5, 390, 0, 0, 1144, 1146, + 5, 574, 0, 0, 1145, 1144, 1, 0, 0, 0, 1145, 1146, 1, 0, 0, 0, 1146, 1147, + 1, 0, 0, 0, 1147, 1156, 7, 0, 0, 0, 1148, 1149, 5, 1018, 0, 0, 1149, 1150, + 3, 1058, 529, 0, 1150, 1152, 5, 897, 0, 0, 1151, 1153, 3, 14, 7, 0, 1152, + 1151, 1, 0, 0, 0, 1153, 1154, 1, 0, 0, 0, 1154, 1152, 1, 0, 0, 0, 1154, + 1155, 1, 0, 0, 0, 1155, 1157, 1, 0, 0, 0, 1156, 1148, 1, 0, 0, 0, 1157, + 1158, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, + 1162, 1, 0, 0, 0, 1160, 1161, 5, 253, 0, 0, 1161, 1163, 3, 14, 7, 0, 1162, + 1160, 1, 0, 0, 0, 1162, 1163, 1, 0, 0, 0, 1163, 1164, 1, 0, 0, 0, 1164, + 1165, 3, 1056, 528, 0, 1165, 1167, 1, 0, 0, 0, 1166, 1137, 1, 0, 0, 0, + 1166, 1143, 1, 0, 0, 0, 1167, 13, 1, 0, 0, 0, 1168, 1169, 5, 397, 0, 0, + 1169, 1174, 3, 878, 439, 0, 1170, 1171, 5, 1104, 0, 0, 1171, 1172, 3, 876, + 438, 0, 1172, 1173, 5, 1105, 0, 0, 1173, 1175, 1, 0, 0, 0, 1174, 1170, + 1, 0, 0, 0, 1174, 1175, 1, 0, 0, 0, 1175, 1177, 1, 0, 0, 0, 1176, 1178, + 3, 16, 8, 0, 1177, 1176, 1, 0, 0, 0, 1177, 1178, 1, 0, 0, 0, 1178, 15, + 1, 0, 0, 0, 1179, 1180, 5, 999, 0, 0, 1180, 1181, 5, 1104, 0, 0, 1181, + 1186, 3, 18, 9, 0, 1182, 1183, 5, 1110, 0, 0, 1183, 1185, 3, 18, 9, 0, + 1184, 1182, 1, 0, 0, 0, 1185, 1188, 1, 0, 0, 0, 1186, 1184, 1, 0, 0, 0, + 1186, 1187, 1, 0, 0, 0, 1187, 1189, 1, 0, 0, 0, 1188, 1186, 1, 0, 0, 0, + 1189, 1190, 5, 1105, 0, 0, 1190, 17, 1, 0, 0, 0, 1191, 1195, 3, 874, 437, + 0, 1192, 1195, 5, 221, 0, 0, 1193, 1195, 5, 522, 0, 0, 1194, 1191, 1, 0, + 0, 0, 1194, 1192, 1, 0, 0, 0, 1194, 1193, 1, 0, 0, 0, 1195, 19, 1, 0, 0, + 0, 1196, 1197, 5, 472, 0, 0, 1197, 1198, 5, 397, 0, 0, 1198, 1199, 3, 878, + 439, 0, 1199, 1200, 5, 992, 0, 0, 1200, 1201, 3, 982, 491, 0, 1201, 1202, + 5, 553, 0, 0, 1202, 1203, 3, 1050, 525, 0, 1203, 1204, 3, 22, 11, 0, 1204, + 21, 1, 0, 0, 0, 1205, 1206, 5, 1018, 0, 0, 1206, 1209, 5, 459, 0, 0, 1207, + 1208, 5, 40, 0, 0, 1208, 1210, 3, 1050, 525, 0, 1209, 1207, 1, 0, 0, 0, + 1209, 1210, 1, 0, 0, 0, 1210, 1211, 1, 0, 0, 0, 1211, 1212, 5, 897, 0, + 0, 1212, 1223, 3, 24, 12, 0, 1213, 1214, 5, 1018, 0, 0, 1214, 1215, 5, + 511, 0, 0, 1215, 1218, 5, 459, 0, 0, 1216, 1217, 5, 40, 0, 0, 1217, 1219, + 3, 1050, 525, 0, 1218, 1216, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, + 1220, 1, 0, 0, 0, 1220, 1221, 5, 897, 0, 0, 1221, 1223, 3, 26, 13, 0, 1222, + 1205, 1, 0, 0, 0, 1222, 1213, 1, 0, 0, 0, 1223, 23, 1, 0, 0, 0, 1224, 1225, + 5, 977, 0, 0, 1225, 1229, 5, 783, 0, 0, 1226, 1227, 3, 1012, 506, 0, 1227, + 1228, 5, 1099, 0, 0, 1228, 1230, 1, 0, 0, 0, 1229, 1226, 1, 0, 0, 0, 1229, + 1230, 1, 0, 0, 0, 1230, 1231, 1, 0, 0, 0, 1231, 1232, 3, 874, 437, 0, 1232, + 1233, 5, 1092, 0, 0, 1233, 1240, 3, 886, 443, 0, 1234, 1235, 3, 874, 437, + 0, 1235, 1236, 5, 1092, 0, 0, 1236, 1237, 3, 886, 443, 0, 1237, 1239, 1, + 0, 0, 0, 1238, 1234, 1, 0, 0, 0, 1239, 1242, 1, 0, 0, 0, 1240, 1238, 1, + 0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1245, 1, 0, 0, 0, 1242, 1240, 1, + 0, 0, 0, 1243, 1245, 5, 232, 0, 0, 1244, 1224, 1, 0, 0, 0, 1244, 1243, + 1, 0, 0, 0, 1245, 25, 1, 0, 0, 0, 1246, 1251, 5, 390, 0, 0, 1247, 1248, + 5, 1104, 0, 0, 1248, 1249, 3, 876, 438, 0, 1249, 1250, 5, 1105, 0, 0, 1250, + 1252, 1, 0, 0, 0, 1251, 1247, 1, 0, 0, 0, 1251, 1252, 1, 0, 0, 0, 1252, + 1253, 1, 0, 0, 0, 1253, 1254, 5, 999, 0, 0, 1254, 1255, 5, 1104, 0, 0, + 1255, 1256, 3, 882, 441, 0, 1256, 1257, 5, 1105, 0, 0, 1257, 27, 1, 0, + 0, 0, 1258, 1259, 5, 977, 0, 0, 1259, 1260, 3, 878, 439, 0, 1260, 1261, + 5, 783, 0, 0, 1261, 1262, 3, 874, 437, 0, 1262, 1263, 5, 1092, 0, 0, 1263, + 1271, 3, 886, 443, 0, 1264, 1265, 5, 1110, 0, 0, 1265, 1266, 3, 874, 437, + 0, 1266, 1267, 5, 1092, 0, 0, 1267, 1268, 3, 886, 443, 0, 1268, 1270, 1, + 0, 0, 0, 1269, 1264, 1, 0, 0, 0, 1270, 1273, 1, 0, 0, 0, 1271, 1269, 1, + 0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 1276, 1, 0, 0, 0, 1273, 1271, 1, + 0, 0, 0, 1274, 1275, 5, 329, 0, 0, 1275, 1277, 3, 980, 490, 0, 1276, 1274, + 1, 0, 0, 0, 1276, 1277, 1, 0, 0, 0, 1277, 1280, 1, 0, 0, 0, 1278, 1279, + 5, 1019, 0, 0, 1279, 1281, 3, 1050, 525, 0, 1280, 1278, 1, 0, 0, 0, 1280, + 1281, 1, 0, 0, 0, 1281, 29, 1, 0, 0, 0, 1282, 1288, 3, 878, 439, 0, 1283, + 1284, 5, 1104, 0, 0, 1284, 1285, 3, 1056, 528, 0, 1285, 1286, 5, 1105, + 0, 0, 1286, 1288, 1, 0, 0, 0, 1287, 1282, 1, 0, 0, 0, 1287, 1283, 1, 0, + 0, 0, 1288, 31, 1, 0, 0, 0, 1289, 1290, 5, 232, 0, 0, 1290, 1291, 5, 329, + 0, 0, 1291, 1298, 3, 878, 439, 0, 1292, 1293, 5, 992, 0, 0, 1293, 1296, + 3, 30, 15, 0, 1294, 1295, 5, 1110, 0, 0, 1295, 1297, 3, 30, 15, 0, 1296, + 1294, 1, 0, 0, 0, 1296, 1297, 1, 0, 0, 0, 1297, 1299, 1, 0, 0, 0, 1298, + 1292, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1302, 1, 0, 0, 0, 1300, + 1301, 5, 1019, 0, 0, 1301, 1303, 3, 1050, 525, 0, 1302, 1300, 1, 0, 0, + 0, 1302, 1303, 1, 0, 0, 0, 1303, 33, 1, 0, 0, 0, 1304, 1305, 5, 999, 0, + 0, 1305, 1306, 5, 1104, 0, 0, 1306, 1307, 3, 882, 441, 0, 1307, 1313, 5, + 1105, 0, 0, 1308, 1309, 5, 1110, 0, 0, 1309, 1310, 5, 1104, 0, 0, 1310, + 1311, 3, 882, 441, 0, 1311, 1312, 5, 1105, 0, 0, 1312, 1314, 1, 0, 0, 0, + 1313, 1308, 1, 0, 0, 0, 1313, 1314, 1, 0, 0, 0, 1314, 35, 1, 0, 0, 0, 1315, + 1340, 3, 38, 19, 0, 1316, 1340, 3, 52, 26, 0, 1317, 1340, 3, 54, 27, 0, + 1318, 1340, 3, 56, 28, 0, 1319, 1340, 3, 58, 29, 0, 1320, 1340, 3, 60, + 30, 0, 1321, 1340, 3, 62, 31, 0, 1322, 1340, 3, 66, 33, 0, 1323, 1340, + 3, 68, 34, 0, 1324, 1340, 3, 70, 35, 0, 1325, 1340, 3, 88, 44, 0, 1326, + 1340, 3, 92, 46, 0, 1327, 1340, 3, 98, 49, 0, 1328, 1340, 3, 104, 52, 0, + 1329, 1340, 3, 106, 53, 0, 1330, 1340, 3, 108, 54, 0, 1331, 1340, 3, 110, + 55, 0, 1332, 1340, 3, 112, 56, 0, 1333, 1340, 3, 114, 57, 0, 1334, 1340, + 3, 116, 58, 0, 1335, 1340, 3, 118, 59, 0, 1336, 1340, 3, 120, 60, 0, 1337, + 1340, 3, 122, 61, 0, 1338, 1340, 3, 532, 266, 0, 1339, 1315, 1, 0, 0, 0, + 1339, 1316, 1, 0, 0, 0, 1339, 1317, 1, 0, 0, 0, 1339, 1318, 1, 0, 0, 0, + 1339, 1319, 1, 0, 0, 0, 1339, 1320, 1, 0, 0, 0, 1339, 1321, 1, 0, 0, 0, + 1339, 1322, 1, 0, 0, 0, 1339, 1323, 1, 0, 0, 0, 1339, 1324, 1, 0, 0, 0, + 1339, 1325, 1, 0, 0, 0, 1339, 1326, 1, 0, 0, 0, 1339, 1327, 1, 0, 0, 0, + 1339, 1328, 1, 0, 0, 0, 1339, 1329, 1, 0, 0, 0, 1339, 1330, 1, 0, 0, 0, + 1339, 1331, 1, 0, 0, 0, 1339, 1332, 1, 0, 0, 0, 1339, 1333, 1, 0, 0, 0, + 1339, 1334, 1, 0, 0, 0, 1339, 1335, 1, 0, 0, 0, 1339, 1336, 1, 0, 0, 0, + 1339, 1337, 1, 0, 0, 0, 1339, 1338, 1, 0, 0, 0, 1340, 37, 1, 0, 0, 0, 1341, + 1342, 5, 185, 0, 0, 1342, 1343, 5, 397, 0, 0, 1343, 1344, 3, 878, 439, + 0, 1344, 1348, 5, 329, 0, 0, 1345, 1349, 3, 100, 50, 0, 1346, 1349, 3, + 102, 51, 0, 1347, 1349, 3, 40, 20, 0, 1348, 1345, 1, 0, 0, 0, 1348, 1346, + 1, 0, 0, 0, 1348, 1347, 1, 0, 0, 0, 1349, 1351, 1, 0, 0, 0, 1350, 1352, + 3, 42, 21, 0, 1351, 1350, 1, 0, 0, 0, 1351, 1352, 1, 0, 0, 0, 1352, 1354, + 1, 0, 0, 0, 1353, 1355, 3, 872, 436, 0, 1354, 1353, 1, 0, 0, 0, 1354, 1355, + 1, 0, 0, 0, 1355, 1357, 1, 0, 0, 0, 1356, 1358, 3, 44, 22, 0, 1357, 1356, + 1, 0, 0, 0, 1357, 1358, 1, 0, 0, 0, 1358, 1362, 1, 0, 0, 0, 1359, 1361, + 3, 428, 214, 0, 1360, 1359, 1, 0, 0, 0, 1361, 1364, 1, 0, 0, 0, 1362, 1360, + 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1368, 1, 0, 0, 0, 1364, 1362, + 1, 0, 0, 0, 1365, 1366, 5, 996, 0, 0, 1366, 1367, 5, 1092, 0, 0, 1367, + 1369, 7, 1, 0, 0, 1368, 1365, 1, 0, 0, 0, 1368, 1369, 1, 0, 0, 0, 1369, + 1395, 1, 0, 0, 0, 1370, 1371, 5, 185, 0, 0, 1371, 1372, 5, 397, 0, 0, 1372, + 1377, 3, 878, 439, 0, 1373, 1374, 5, 1104, 0, 0, 1374, 1375, 3, 876, 438, + 0, 1375, 1376, 5, 1105, 0, 0, 1376, 1378, 1, 0, 0, 0, 1377, 1373, 1, 0, + 0, 0, 1377, 1378, 1, 0, 0, 0, 1378, 1380, 1, 0, 0, 0, 1379, 1381, 3, 42, + 21, 0, 1380, 1379, 1, 0, 0, 0, 1380, 1381, 1, 0, 0, 0, 1381, 1383, 1, 0, + 0, 0, 1382, 1384, 3, 872, 436, 0, 1383, 1382, 1, 0, 0, 0, 1383, 1384, 1, + 0, 0, 0, 1384, 1386, 1, 0, 0, 0, 1385, 1387, 3, 44, 22, 0, 1386, 1385, + 1, 0, 0, 0, 1386, 1387, 1, 0, 0, 0, 1387, 1391, 1, 0, 0, 0, 1388, 1390, + 3, 428, 214, 0, 1389, 1388, 1, 0, 0, 0, 1390, 1393, 1, 0, 0, 0, 1391, 1389, + 1, 0, 0, 0, 1391, 1392, 1, 0, 0, 0, 1392, 1395, 1, 0, 0, 0, 1393, 1391, + 1, 0, 0, 0, 1394, 1341, 1, 0, 0, 0, 1394, 1370, 1, 0, 0, 0, 1395, 39, 1, + 0, 0, 0, 1396, 1397, 7, 2, 0, 0, 1397, 41, 1, 0, 0, 0, 1398, 1399, 5, 315, + 0, 0, 1399, 1400, 5, 1092, 0, 0, 1400, 1401, 5, 1104, 0, 0, 1401, 1406, + 3, 852, 426, 0, 1402, 1403, 5, 1110, 0, 0, 1403, 1405, 3, 852, 426, 0, + 1404, 1402, 1, 0, 0, 0, 1405, 1408, 1, 0, 0, 0, 1406, 1404, 1, 0, 0, 0, + 1406, 1407, 1, 0, 0, 0, 1407, 1409, 1, 0, 0, 0, 1408, 1406, 1, 0, 0, 0, + 1409, 1410, 5, 1105, 0, 0, 1410, 43, 1, 0, 0, 0, 1411, 1412, 5, 317, 0, + 0, 1412, 1413, 5, 1092, 0, 0, 1413, 1416, 5, 1104, 0, 0, 1414, 1417, 3, + 46, 23, 0, 1415, 1417, 3, 48, 24, 0, 1416, 1414, 1, 0, 0, 0, 1416, 1415, + 1, 0, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, 1419, 5, 1105, 0, 0, 1419, 45, + 1, 0, 0, 0, 1420, 1421, 5, 327, 0, 0, 1421, 1422, 5, 1092, 0, 0, 1422, + 1423, 3, 852, 426, 0, 1423, 47, 1, 0, 0, 0, 1424, 1425, 5, 954, 0, 0, 1425, + 1426, 5, 1092, 0, 0, 1426, 1430, 7, 3, 0, 0, 1427, 1429, 3, 426, 213, 0, + 1428, 1427, 1, 0, 0, 0, 1429, 1432, 1, 0, 0, 0, 1430, 1428, 1, 0, 0, 0, + 1430, 1431, 1, 0, 0, 0, 1431, 49, 1, 0, 0, 0, 1432, 1430, 1, 0, 0, 0, 1433, + 1434, 5, 825, 0, 0, 1434, 1435, 5, 1092, 0, 0, 1435, 1436, 5, 1104, 0, + 0, 1436, 1437, 5, 327, 0, 0, 1437, 1438, 5, 1092, 0, 0, 1438, 1450, 3, + 852, 426, 0, 1439, 1440, 5, 954, 0, 0, 1440, 1441, 5, 1092, 0, 0, 1441, + 1443, 7, 3, 0, 0, 1442, 1444, 3, 426, 213, 0, 1443, 1442, 1, 0, 0, 0, 1444, + 1445, 1, 0, 0, 0, 1445, 1443, 1, 0, 0, 0, 1445, 1446, 1, 0, 0, 0, 1446, + 1447, 1, 0, 0, 0, 1447, 1448, 5, 1105, 0, 0, 1448, 1450, 1, 0, 0, 0, 1449, + 1433, 1, 0, 0, 0, 1449, 1439, 1, 0, 0, 0, 1450, 51, 1, 0, 0, 0, 1451, 1452, + 5, 185, 0, 0, 1452, 1456, 5, 397, 0, 0, 1453, 1457, 3, 100, 50, 0, 1454, + 1457, 3, 102, 51, 0, 1455, 1457, 3, 40, 20, 0, 1456, 1453, 1, 0, 0, 0, + 1456, 1454, 1, 0, 0, 0, 1456, 1455, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, + 1458, 1464, 5, 329, 0, 0, 1459, 1465, 3, 878, 439, 0, 1460, 1461, 5, 1104, + 0, 0, 1461, 1462, 3, 932, 466, 0, 1462, 1463, 5, 1105, 0, 0, 1463, 1465, + 1, 0, 0, 0, 1464, 1459, 1, 0, 0, 0, 1464, 1460, 1, 0, 0, 0, 1465, 1467, + 1, 0, 0, 0, 1466, 1468, 3, 1010, 505, 0, 1467, 1466, 1, 0, 0, 0, 1467, + 1468, 1, 0, 0, 0, 1468, 1470, 1, 0, 0, 0, 1469, 1471, 3, 44, 22, 0, 1470, + 1469, 1, 0, 0, 0, 1470, 1471, 1, 0, 0, 0, 1471, 1473, 1, 0, 0, 0, 1472, + 1474, 3, 428, 214, 0, 1473, 1472, 1, 0, 0, 0, 1473, 1474, 1, 0, 0, 0, 1474, + 1478, 1, 0, 0, 0, 1475, 1476, 5, 996, 0, 0, 1476, 1477, 5, 1092, 0, 0, + 1477, 1479, 5, 711, 0, 0, 1478, 1475, 1, 0, 0, 0, 1478, 1479, 1, 0, 0, + 0, 1479, 1481, 1, 0, 0, 0, 1480, 1482, 5, 356, 0, 0, 1481, 1480, 1, 0, + 0, 0, 1481, 1482, 1, 0, 0, 0, 1482, 53, 1, 0, 0, 0, 1483, 1485, 5, 161, + 0, 0, 1484, 1486, 3, 650, 325, 0, 1485, 1484, 1, 0, 0, 0, 1485, 1486, 1, + 0, 0, 0, 1486, 1487, 1, 0, 0, 0, 1487, 1488, 5, 553, 0, 0, 1488, 1489, + 3, 548, 274, 0, 1489, 1490, 3, 878, 439, 0, 1490, 1491, 5, 398, 0, 0, 1491, + 1492, 3, 852, 426, 0, 1492, 1504, 1, 0, 0, 0, 1493, 1495, 5, 161, 0, 0, + 1494, 1496, 3, 650, 325, 0, 1495, 1494, 1, 0, 0, 0, 1495, 1496, 1, 0, 0, + 0, 1496, 1497, 1, 0, 0, 0, 1497, 1498, 5, 553, 0, 0, 1498, 1499, 5, 157, + 0, 0, 1499, 1500, 3, 922, 461, 0, 1500, 1501, 5, 398, 0, 0, 1501, 1502, + 3, 852, 426, 0, 1502, 1504, 1, 0, 0, 0, 1503, 1483, 1, 0, 0, 0, 1503, 1493, + 1, 0, 0, 0, 1504, 55, 1, 0, 0, 0, 1505, 1507, 5, 162, 0, 0, 1506, 1508, + 5, 1024, 0, 0, 1507, 1506, 1, 0, 0, 0, 1507, 1508, 1, 0, 0, 0, 1508, 57, + 1, 0, 0, 0, 1509, 1510, 5, 282, 0, 0, 1510, 1511, 5, 374, 0, 0, 1511, 1524, + 3, 852, 426, 0, 1512, 1513, 5, 992, 0, 0, 1513, 1514, 5, 1104, 0, 0, 1514, + 1519, 3, 856, 428, 0, 1515, 1516, 5, 1110, 0, 0, 1516, 1518, 3, 856, 428, + 0, 1517, 1515, 1, 0, 0, 0, 1518, 1521, 1, 0, 0, 0, 1519, 1517, 1, 0, 0, + 0, 1519, 1520, 1, 0, 0, 0, 1520, 1522, 1, 0, 0, 0, 1521, 1519, 1, 0, 0, + 0, 1522, 1523, 5, 1105, 0, 0, 1523, 1525, 1, 0, 0, 0, 1524, 1512, 1, 0, + 0, 0, 1524, 1525, 1, 0, 0, 0, 1525, 1561, 1, 0, 0, 0, 1526, 1527, 5, 282, + 0, 0, 1527, 1528, 5, 374, 0, 0, 1528, 1541, 3, 856, 428, 0, 1529, 1530, + 5, 992, 0, 0, 1530, 1531, 5, 1104, 0, 0, 1531, 1536, 3, 856, 428, 0, 1532, + 1533, 5, 1110, 0, 0, 1533, 1535, 3, 856, 428, 0, 1534, 1532, 1, 0, 0, 0, + 1535, 1538, 1, 0, 0, 0, 1536, 1534, 1, 0, 0, 0, 1536, 1537, 1, 0, 0, 0, + 1537, 1539, 1, 0, 0, 0, 1538, 1536, 1, 0, 0, 0, 1539, 1540, 5, 1105, 0, + 0, 1540, 1542, 1, 0, 0, 0, 1541, 1529, 1, 0, 0, 0, 1541, 1542, 1, 0, 0, + 0, 1542, 1561, 1, 0, 0, 0, 1543, 1544, 5, 282, 0, 0, 1544, 1545, 5, 374, + 0, 0, 1545, 1558, 5, 1077, 0, 0, 1546, 1547, 5, 992, 0, 0, 1547, 1548, + 5, 1104, 0, 0, 1548, 1553, 3, 856, 428, 0, 1549, 1550, 5, 1110, 0, 0, 1550, + 1552, 3, 856, 428, 0, 1551, 1549, 1, 0, 0, 0, 1552, 1555, 1, 0, 0, 0, 1553, + 1551, 1, 0, 0, 0, 1553, 1554, 1, 0, 0, 0, 1554, 1556, 1, 0, 0, 0, 1555, + 1553, 1, 0, 0, 0, 1556, 1557, 5, 1105, 0, 0, 1557, 1559, 1, 0, 0, 0, 1558, + 1546, 1, 0, 0, 0, 1558, 1559, 1, 0, 0, 0, 1559, 1561, 1, 0, 0, 0, 1560, + 1509, 1, 0, 0, 0, 1560, 1526, 1, 0, 0, 0, 1560, 1543, 1, 0, 0, 0, 1561, + 59, 1, 0, 0, 0, 1562, 1563, 5, 282, 0, 0, 1563, 1564, 5, 891, 0, 0, 1564, + 1565, 3, 878, 439, 0, 1565, 61, 1, 0, 0, 0, 1566, 1569, 5, 289, 0, 0, 1567, + 1568, 5, 992, 0, 0, 1568, 1570, 7, 4, 0, 0, 1569, 1567, 1, 0, 0, 0, 1569, + 1570, 1, 0, 0, 0, 1570, 1571, 1, 0, 0, 0, 1571, 1572, 3, 4, 2, 0, 1572, + 63, 1, 0, 0, 0, 1573, 1574, 5, 578, 0, 0, 1574, 1575, 5, 1092, 0, 0, 1575, + 1576, 3, 880, 440, 0, 1576, 65, 1, 0, 0, 0, 1577, 1578, 5, 343, 0, 0, 1578, + 1579, 3, 100, 50, 0, 1579, 1581, 5, 1081, 0, 0, 1580, 1582, 3, 64, 32, + 0, 1581, 1580, 1, 0, 0, 0, 1581, 1582, 1, 0, 0, 0, 1582, 1584, 1, 0, 0, + 0, 1583, 1585, 3, 872, 436, 0, 1584, 1583, 1, 0, 0, 0, 1584, 1585, 1, 0, + 0, 0, 1585, 67, 1, 0, 0, 0, 1586, 1587, 5, 348, 0, 0, 1587, 1613, 5, 576, + 0, 0, 1588, 1601, 5, 553, 0, 0, 1589, 1590, 3, 548, 274, 0, 1590, 1591, + 3, 878, 439, 0, 1591, 1602, 1, 0, 0, 0, 1592, 1593, 5, 23, 0, 0, 1593, + 1594, 3, 550, 275, 0, 1594, 1599, 5, 380, 0, 0, 1595, 1596, 5, 207, 0, + 0, 1596, 1600, 3, 856, 428, 0, 1597, 1598, 5, 757, 0, 0, 1598, 1600, 3, + 834, 417, 0, 1599, 1595, 1, 0, 0, 0, 1599, 1597, 1, 0, 0, 0, 1600, 1602, + 1, 0, 0, 0, 1601, 1589, 1, 0, 0, 0, 1601, 1592, 1, 0, 0, 0, 1602, 1614, + 1, 0, 0, 0, 1603, 1604, 5, 553, 0, 0, 1604, 1605, 5, 333, 0, 0, 1605, 1606, + 3, 550, 275, 0, 1606, 1611, 5, 380, 0, 0, 1607, 1608, 5, 207, 0, 0, 1608, + 1612, 3, 856, 428, 0, 1609, 1610, 5, 757, 0, 0, 1610, 1612, 3, 834, 417, + 0, 1611, 1607, 1, 0, 0, 0, 1611, 1609, 1, 0, 0, 0, 1612, 1614, 1, 0, 0, + 0, 1613, 1588, 1, 0, 0, 0, 1613, 1603, 1, 0, 0, 0, 1614, 1615, 1, 0, 0, + 0, 1615, 1616, 5, 922, 0, 0, 1616, 1617, 5, 718, 0, 0, 1617, 1621, 3, 856, + 428, 0, 1618, 1619, 7, 5, 0, 0, 1619, 1620, 5, 198, 0, 0, 1620, 1622, 5, + 349, 0, 0, 1621, 1618, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 69, 1, + 0, 0, 0, 1623, 1719, 5, 348, 0, 0, 1624, 1630, 3, 72, 36, 0, 1625, 1627, + 5, 23, 0, 0, 1626, 1628, 5, 626, 0, 0, 1627, 1626, 1, 0, 0, 0, 1627, 1628, + 1, 0, 0, 0, 1628, 1630, 1, 0, 0, 0, 1629, 1624, 1, 0, 0, 0, 1629, 1625, + 1, 0, 0, 0, 1630, 1631, 1, 0, 0, 0, 1631, 1632, 5, 553, 0, 0, 1632, 1720, + 5, 9, 0, 0, 1633, 1639, 3, 76, 38, 0, 1634, 1636, 5, 23, 0, 0, 1635, 1637, + 5, 626, 0, 0, 1636, 1635, 1, 0, 0, 0, 1636, 1637, 1, 0, 0, 0, 1637, 1639, + 1, 0, 0, 0, 1638, 1633, 1, 0, 0, 0, 1638, 1634, 1, 0, 0, 0, 1639, 1640, + 1, 0, 0, 0, 1640, 1647, 5, 553, 0, 0, 1641, 1648, 5, 984, 0, 0, 1642, 1643, + 5, 694, 0, 0, 1643, 1648, 5, 484, 0, 0, 1644, 1648, 5, 1011, 0, 0, 1645, + 1648, 5, 207, 0, 0, 1646, 1648, 5, 394, 0, 0, 1647, 1641, 1, 0, 0, 0, 1647, + 1642, 1, 0, 0, 0, 1647, 1644, 1, 0, 0, 0, 1647, 1645, 1, 0, 0, 0, 1647, + 1646, 1, 0, 0, 0, 1648, 1649, 1, 0, 0, 0, 1649, 1720, 3, 878, 439, 0, 1650, + 1656, 3, 80, 40, 0, 1651, 1653, 5, 23, 0, 0, 1652, 1654, 5, 626, 0, 0, + 1653, 1652, 1, 0, 0, 0, 1653, 1654, 1, 0, 0, 0, 1654, 1656, 1, 0, 0, 0, + 1655, 1650, 1, 0, 0, 0, 1655, 1651, 1, 0, 0, 0, 1656, 1657, 1, 0, 0, 0, + 1657, 1665, 5, 553, 0, 0, 1658, 1659, 5, 757, 0, 0, 1659, 1666, 3, 834, + 417, 0, 1660, 1661, 5, 23, 0, 0, 1661, 1662, 5, 758, 0, 0, 1662, 1663, + 5, 380, 0, 0, 1663, 1664, 5, 207, 0, 0, 1664, 1666, 3, 856, 428, 0, 1665, + 1658, 1, 0, 0, 0, 1665, 1660, 1, 0, 0, 0, 1666, 1720, 1, 0, 0, 0, 1667, + 1673, 3, 80, 40, 0, 1668, 1670, 5, 23, 0, 0, 1669, 1671, 5, 626, 0, 0, + 1670, 1669, 1, 0, 0, 0, 1670, 1671, 1, 0, 0, 0, 1671, 1673, 1, 0, 0, 0, + 1672, 1667, 1, 0, 0, 0, 1672, 1668, 1, 0, 0, 0, 1673, 1674, 1, 0, 0, 0, + 1674, 1675, 5, 553, 0, 0, 1675, 1676, 5, 333, 0, 0, 1676, 1677, 5, 758, + 0, 0, 1677, 1678, 5, 380, 0, 0, 1678, 1679, 5, 207, 0, 0, 1679, 1720, 3, + 856, 428, 0, 1680, 1686, 3, 84, 42, 0, 1681, 1683, 5, 23, 0, 0, 1682, 1684, + 5, 626, 0, 0, 1683, 1682, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, 0, 1684, 1686, + 1, 0, 0, 0, 1685, 1680, 1, 0, 0, 0, 1685, 1681, 1, 0, 0, 0, 1686, 1687, + 1, 0, 0, 0, 1687, 1700, 5, 553, 0, 0, 1688, 1689, 3, 836, 418, 0, 1689, + 1690, 3, 878, 439, 0, 1690, 1701, 1, 0, 0, 0, 1691, 1692, 5, 23, 0, 0, + 1692, 1693, 3, 550, 275, 0, 1693, 1698, 5, 380, 0, 0, 1694, 1695, 5, 207, + 0, 0, 1695, 1699, 3, 856, 428, 0, 1696, 1697, 5, 757, 0, 0, 1697, 1699, + 3, 834, 417, 0, 1698, 1694, 1, 0, 0, 0, 1698, 1696, 1, 0, 0, 0, 1699, 1701, + 1, 0, 0, 0, 1700, 1688, 1, 0, 0, 0, 1700, 1691, 1, 0, 0, 0, 1701, 1720, + 1, 0, 0, 0, 1702, 1708, 3, 84, 42, 0, 1703, 1705, 5, 23, 0, 0, 1704, 1706, + 5, 626, 0, 0, 1705, 1704, 1, 0, 0, 0, 1705, 1706, 1, 0, 0, 0, 1706, 1708, + 1, 0, 0, 0, 1707, 1702, 1, 0, 0, 0, 1707, 1703, 1, 0, 0, 0, 1708, 1709, + 1, 0, 0, 0, 1709, 1710, 5, 553, 0, 0, 1710, 1711, 5, 333, 0, 0, 1711, 1712, + 3, 550, 275, 0, 1712, 1717, 5, 380, 0, 0, 1713, 1714, 5, 207, 0, 0, 1714, + 1718, 3, 856, 428, 0, 1715, 1716, 5, 757, 0, 0, 1716, 1718, 3, 834, 417, + 0, 1717, 1713, 1, 0, 0, 0, 1717, 1715, 1, 0, 0, 0, 1718, 1720, 1, 0, 0, + 0, 1719, 1629, 1, 0, 0, 0, 1719, 1638, 1, 0, 0, 0, 1719, 1655, 1, 0, 0, + 0, 1719, 1672, 1, 0, 0, 0, 1719, 1685, 1, 0, 0, 0, 1719, 1707, 1, 0, 0, + 0, 1720, 1721, 1, 0, 0, 0, 1721, 1723, 5, 922, 0, 0, 1722, 1724, 5, 718, + 0, 0, 1723, 1722, 1, 0, 0, 0, 1723, 1724, 1, 0, 0, 0, 1724, 1725, 1, 0, + 0, 0, 1725, 1729, 3, 856, 428, 0, 1726, 1727, 5, 1020, 0, 0, 1727, 1728, + 5, 348, 0, 0, 1728, 1730, 5, 563, 0, 0, 1729, 1726, 1, 0, 0, 0, 1729, 1730, + 1, 0, 0, 0, 1730, 71, 1, 0, 0, 0, 1731, 1736, 3, 74, 37, 0, 1732, 1733, + 5, 1110, 0, 0, 1733, 1735, 3, 74, 37, 0, 1734, 1732, 1, 0, 0, 0, 1735, + 1738, 1, 0, 0, 0, 1736, 1734, 1, 0, 0, 0, 1736, 1737, 1, 0, 0, 0, 1737, + 73, 1, 0, 0, 0, 1738, 1736, 1, 0, 0, 0, 1739, 1752, 5, 190, 0, 0, 1740, + 1753, 5, 9, 0, 0, 1741, 1742, 5, 206, 0, 0, 1742, 1743, 5, 281, 0, 0, 1743, + 1753, 5, 436, 0, 0, 1744, 1753, 5, 207, 0, 0, 1745, 1753, 5, 394, 0, 0, + 1746, 1747, 5, 496, 0, 0, 1747, 1753, 5, 608, 0, 0, 1748, 1753, 5, 718, + 0, 0, 1749, 1753, 5, 786, 0, 0, 1750, 1753, 5, 984, 0, 0, 1751, 1753, 5, + 1011, 0, 0, 1752, 1740, 1, 0, 0, 0, 1752, 1741, 1, 0, 0, 0, 1752, 1744, + 1, 0, 0, 0, 1752, 1745, 1, 0, 0, 0, 1752, 1746, 1, 0, 0, 0, 1752, 1748, + 1, 0, 0, 0, 1752, 1749, 1, 0, 0, 0, 1752, 1750, 1, 0, 0, 0, 1752, 1751, + 1, 0, 0, 0, 1753, 1784, 1, 0, 0, 0, 1754, 1755, 5, 54, 0, 0, 1755, 1756, + 5, 455, 0, 0, 1756, 1769, 5, 608, 0, 0, 1757, 1758, 5, 54, 0, 0, 1758, + 1759, 5, 723, 0, 0, 1759, 1760, 5, 8, 0, 0, 1760, 1769, 5, 608, 0, 0, 1761, + 1762, 5, 54, 0, 0, 1762, 1763, 5, 779, 0, 0, 1763, 1769, 5, 608, 0, 0, + 1764, 1765, 5, 54, 0, 0, 1765, 1769, 5, 887, 0, 0, 1766, 1767, 5, 58, 0, + 0, 1767, 1769, 5, 608, 0, 0, 1768, 1754, 1, 0, 0, 0, 1768, 1757, 1, 0, + 0, 0, 1768, 1761, 1, 0, 0, 0, 1768, 1764, 1, 0, 0, 0, 1768, 1766, 1, 0, + 0, 0, 1769, 1784, 1, 0, 0, 0, 1770, 1771, 5, 282, 0, 0, 1771, 1782, 5, + 891, 0, 0, 1772, 1773, 5, 378, 0, 0, 1773, 1782, 5, 786, 0, 0, 1774, 1775, + 5, 451, 0, 0, 1775, 1782, 5, 349, 0, 0, 1776, 1777, 5, 484, 0, 0, 1777, + 1782, 7, 6, 0, 0, 1778, 1779, 5, 573, 0, 0, 1779, 1780, 5, 786, 0, 0, 1780, + 1782, 5, 701, 0, 0, 1781, 1770, 1, 0, 0, 0, 1781, 1772, 1, 0, 0, 0, 1781, + 1774, 1, 0, 0, 0, 1781, 1776, 1, 0, 0, 0, 1781, 1778, 1, 0, 0, 0, 1782, + 1784, 1, 0, 0, 0, 1783, 1739, 1, 0, 0, 0, 1783, 1768, 1, 0, 0, 0, 1783, + 1781, 1, 0, 0, 0, 1784, 75, 1, 0, 0, 0, 1785, 1790, 3, 78, 39, 0, 1786, + 1787, 5, 1110, 0, 0, 1787, 1789, 3, 78, 39, 0, 1788, 1786, 1, 0, 0, 0, + 1789, 1792, 1, 0, 0, 0, 1790, 1788, 1, 0, 0, 0, 1790, 1791, 1, 0, 0, 0, + 1791, 77, 1, 0, 0, 0, 1792, 1790, 1, 0, 0, 0, 1793, 1803, 5, 484, 0, 0, + 1794, 1803, 5, 483, 0, 0, 1795, 1803, 5, 981, 0, 0, 1796, 1803, 5, 560, + 0, 0, 1797, 1798, 5, 190, 0, 0, 1798, 1803, 5, 757, 0, 0, 1799, 1800, 5, + 379, 0, 0, 1800, 1803, 5, 626, 0, 0, 1801, 1803, 5, 990, 0, 0, 1802, 1793, + 1, 0, 0, 0, 1802, 1794, 1, 0, 0, 0, 1802, 1795, 1, 0, 0, 0, 1802, 1796, + 1, 0, 0, 0, 1802, 1797, 1, 0, 0, 0, 1802, 1799, 1, 0, 0, 0, 1802, 1801, + 1, 0, 0, 0, 1803, 79, 1, 0, 0, 0, 1804, 1809, 3, 82, 41, 0, 1805, 1806, + 5, 1110, 0, 0, 1806, 1808, 3, 82, 41, 0, 1807, 1805, 1, 0, 0, 0, 1808, + 1811, 1, 0, 0, 0, 1809, 1807, 1, 0, 0, 0, 1809, 1810, 1, 0, 0, 0, 1810, + 81, 1, 0, 0, 0, 1811, 1809, 1, 0, 0, 0, 1812, 1845, 5, 483, 0, 0, 1813, + 1845, 5, 484, 0, 0, 1814, 1845, 5, 981, 0, 0, 1815, 1839, 5, 190, 0, 0, + 1816, 1840, 5, 880, 0, 0, 1817, 1818, 5, 291, 0, 0, 1818, 1840, 5, 880, + 0, 0, 1819, 1840, 5, 1005, 0, 0, 1820, 1821, 5, 463, 0, 0, 1821, 1840, + 5, 1005, 0, 0, 1822, 1823, 5, 455, 0, 0, 1823, 1840, 5, 608, 0, 0, 1824, + 1825, 5, 723, 0, 0, 1825, 1826, 5, 8, 0, 0, 1826, 1840, 5, 608, 0, 0, 1827, + 1828, 5, 779, 0, 0, 1828, 1840, 5, 608, 0, 0, 1829, 1840, 5, 887, 0, 0, + 1830, 1840, 5, 775, 0, 0, 1831, 1840, 5, 331, 0, 0, 1832, 1840, 5, 628, + 0, 0, 1833, 1834, 5, 314, 0, 0, 1834, 1840, 5, 325, 0, 0, 1835, 1840, 5, + 822, 0, 0, 1836, 1840, 5, 601, 0, 0, 1837, 1840, 5, 857, 0, 0, 1838, 1840, + 5, 891, 0, 0, 1839, 1816, 1, 0, 0, 0, 1839, 1817, 1, 0, 0, 0, 1839, 1819, + 1, 0, 0, 0, 1839, 1820, 1, 0, 0, 0, 1839, 1822, 1, 0, 0, 0, 1839, 1824, + 1, 0, 0, 0, 1839, 1827, 1, 0, 0, 0, 1839, 1829, 1, 0, 0, 0, 1839, 1830, + 1, 0, 0, 0, 1839, 1831, 1, 0, 0, 0, 1839, 1832, 1, 0, 0, 0, 1839, 1833, + 1, 0, 0, 0, 1839, 1835, 1, 0, 0, 0, 1839, 1836, 1, 0, 0, 0, 1839, 1837, + 1, 0, 0, 0, 1839, 1838, 1, 0, 0, 0, 1840, 1845, 1, 0, 0, 0, 1841, 1842, + 5, 14, 0, 0, 1842, 1843, 5, 763, 0, 0, 1843, 1845, 5, 562, 0, 0, 1844, + 1812, 1, 0, 0, 0, 1844, 1813, 1, 0, 0, 0, 1844, 1814, 1, 0, 0, 0, 1844, + 1815, 1, 0, 0, 0, 1844, 1841, 1, 0, 0, 0, 1845, 83, 1, 0, 0, 0, 1846, 1851, + 3, 86, 43, 0, 1847, 1848, 5, 1110, 0, 0, 1848, 1850, 3, 86, 43, 0, 1849, + 1847, 1, 0, 0, 0, 1850, 1853, 1, 0, 0, 0, 1851, 1849, 1, 0, 0, 0, 1851, + 1852, 1, 0, 0, 0, 1852, 85, 1, 0, 0, 0, 1853, 1851, 1, 0, 0, 0, 1854, 1870, + 5, 773, 0, 0, 1855, 1870, 5, 390, 0, 0, 1856, 1870, 5, 977, 0, 0, 1857, + 1870, 5, 232, 0, 0, 1858, 1870, 5, 945, 0, 0, 1859, 1870, 5, 669, 0, 0, + 1860, 1870, 5, 981, 0, 0, 1861, 1864, 5, 650, 0, 0, 1862, 1863, 5, 1110, + 0, 0, 1863, 1865, 5, 1026, 0, 0, 1864, 1862, 1, 0, 0, 0, 1864, 1865, 1, + 0, 0, 0, 1865, 1870, 1, 0, 0, 0, 1866, 1870, 5, 484, 0, 0, 1867, 1870, + 5, 560, 0, 0, 1868, 1870, 5, 54, 0, 0, 1869, 1854, 1, 0, 0, 0, 1869, 1855, + 1, 0, 0, 0, 1869, 1856, 1, 0, 0, 0, 1869, 1857, 1, 0, 0, 0, 1869, 1858, + 1, 0, 0, 0, 1869, 1859, 1, 0, 0, 0, 1869, 1860, 1, 0, 0, 0, 1869, 1861, + 1, 0, 0, 0, 1869, 1866, 1, 0, 0, 0, 1869, 1867, 1, 0, 0, 0, 1869, 1868, + 1, 0, 0, 0, 1870, 87, 1, 0, 0, 0, 1871, 1872, 5, 348, 0, 0, 1872, 1873, + 3, 90, 45, 0, 1873, 1891, 5, 553, 0, 0, 1874, 1875, 5, 207, 0, 0, 1875, + 1892, 3, 856, 428, 0, 1876, 1877, 5, 757, 0, 0, 1877, 1892, 3, 856, 428, + 0, 1878, 1879, 5, 331, 0, 0, 1879, 1892, 3, 856, 428, 0, 1880, 1881, 5, + 880, 0, 0, 1881, 1888, 3, 878, 439, 0, 1882, 1883, 5, 23, 0, 0, 1883, 1884, + 5, 883, 0, 0, 1884, 1885, 5, 380, 0, 0, 1885, 1886, 5, 757, 0, 0, 1886, + 1888, 3, 834, 417, 0, 1887, 1880, 1, 0, 0, 0, 1887, 1882, 1, 0, 0, 0, 1888, + 1892, 1, 0, 0, 0, 1889, 1890, 5, 1005, 0, 0, 1890, 1892, 3, 856, 428, 0, + 1891, 1874, 1, 0, 0, 0, 1891, 1876, 1, 0, 0, 0, 1891, 1878, 1, 0, 0, 0, + 1891, 1887, 1, 0, 0, 0, 1891, 1889, 1, 0, 0, 0, 1892, 1893, 1, 0, 0, 0, + 1893, 1894, 5, 922, 0, 0, 1894, 1895, 5, 786, 0, 0, 1895, 1896, 3, 856, + 428, 0, 1896, 89, 1, 0, 0, 0, 1897, 1898, 7, 7, 0, 0, 1898, 91, 1, 0, 0, + 0, 1899, 1900, 5, 348, 0, 0, 1900, 1901, 5, 718, 0, 0, 1901, 1902, 3, 94, + 47, 0, 1902, 1907, 5, 922, 0, 0, 1903, 1904, 5, 718, 0, 0, 1904, 1908, + 3, 94, 47, 0, 1905, 1906, 5, 984, 0, 0, 1906, 1908, 3, 856, 428, 0, 1907, + 1903, 1, 0, 0, 0, 1907, 1905, 1, 0, 0, 0, 1908, 93, 1, 0, 0, 0, 1909, 1912, + 3, 96, 48, 0, 1910, 1912, 3, 856, 428, 0, 1911, 1909, 1, 0, 0, 0, 1911, + 1910, 1, 0, 0, 0, 1912, 95, 1, 0, 0, 0, 1913, 1914, 7, 8, 0, 0, 1914, 97, + 1, 0, 0, 0, 1915, 1918, 5, 433, 0, 0, 1916, 1919, 3, 100, 50, 0, 1917, + 1919, 3, 102, 51, 0, 1918, 1916, 1, 0, 0, 0, 1918, 1917, 1, 0, 0, 0, 1919, + 1921, 1, 0, 0, 0, 1920, 1922, 3, 872, 436, 0, 1921, 1920, 1, 0, 0, 0, 1921, + 1922, 1, 0, 0, 0, 1922, 99, 1, 0, 0, 0, 1923, 1924, 5, 1101, 0, 0, 1924, + 1925, 3, 856, 428, 0, 1925, 1926, 5, 1115, 0, 0, 1926, 101, 1, 0, 0, 0, + 1927, 1928, 5, 1101, 0, 0, 1928, 1929, 3, 856, 428, 0, 1929, 1930, 5, 1115, + 0, 0, 1930, 103, 1, 0, 0, 0, 1931, 1932, 5, 638, 0, 0, 1932, 1933, 5, 1081, + 0, 0, 1933, 1937, 3, 100, 50, 0, 1934, 1935, 5, 578, 0, 0, 1935, 1936, + 5, 1092, 0, 0, 1936, 1938, 3, 880, 440, 0, 1937, 1934, 1, 0, 0, 0, 1937, + 1938, 1, 0, 0, 0, 1938, 1942, 1, 0, 0, 0, 1939, 1940, 5, 67, 0, 0, 1940, + 1941, 5, 1092, 0, 0, 1941, 1943, 3, 450, 225, 0, 1942, 1939, 1, 0, 0, 0, + 1942, 1943, 1, 0, 0, 0, 1943, 1947, 1, 0, 0, 0, 1944, 1945, 5, 814, 0, + 0, 1945, 1946, 5, 1092, 0, 0, 1946, 1948, 7, 9, 0, 0, 1947, 1944, 1, 0, + 0, 0, 1947, 1948, 1, 0, 0, 0, 1948, 1952, 1, 0, 0, 0, 1949, 1950, 5, 574, + 0, 0, 1950, 1951, 5, 1092, 0, 0, 1951, 1953, 3, 450, 225, 0, 1952, 1949, + 1, 0, 0, 0, 1952, 1953, 1, 0, 0, 0, 1953, 105, 1, 0, 0, 0, 1954, 1957, + 5, 681, 0, 0, 1955, 1958, 3, 100, 50, 0, 1956, 1958, 3, 102, 51, 0, 1957, + 1955, 1, 0, 0, 0, 1957, 1956, 1, 0, 0, 0, 1958, 1960, 1, 0, 0, 0, 1959, + 1961, 3, 872, 436, 0, 1960, 1959, 1, 0, 0, 0, 1960, 1961, 1, 0, 0, 0, 1961, + 107, 1, 0, 0, 0, 1962, 1966, 5, 714, 0, 0, 1963, 1964, 5, 348, 0, 0, 1964, + 1965, 5, 563, 0, 0, 1965, 1967, 5, 322, 0, 0, 1966, 1963, 1, 0, 0, 0, 1966, + 1967, 1, 0, 0, 0, 1967, 2058, 1, 0, 0, 0, 1968, 1974, 3, 74, 37, 0, 1969, + 1971, 5, 23, 0, 0, 1970, 1972, 5, 626, 0, 0, 1971, 1970, 1, 0, 0, 0, 1971, + 1972, 1, 0, 0, 0, 1972, 1974, 1, 0, 0, 0, 1973, 1968, 1, 0, 0, 0, 1973, + 1969, 1, 0, 0, 0, 1974, 1975, 1, 0, 0, 0, 1975, 1976, 5, 553, 0, 0, 1976, + 2059, 5, 9, 0, 0, 1977, 1983, 3, 76, 38, 0, 1978, 1980, 5, 23, 0, 0, 1979, + 1981, 5, 626, 0, 0, 1980, 1979, 1, 0, 0, 0, 1980, 1981, 1, 0, 0, 0, 1981, + 1983, 1, 0, 0, 0, 1982, 1977, 1, 0, 0, 0, 1982, 1978, 1, 0, 0, 0, 1983, + 1984, 1, 0, 0, 0, 1984, 1990, 5, 553, 0, 0, 1985, 1986, 5, 694, 0, 0, 1986, + 1991, 5, 484, 0, 0, 1987, 1991, 5, 1011, 0, 0, 1988, 1991, 5, 207, 0, 0, + 1989, 1991, 5, 394, 0, 0, 1990, 1985, 1, 0, 0, 0, 1990, 1987, 1, 0, 0, + 0, 1990, 1988, 1, 0, 0, 0, 1990, 1989, 1, 0, 0, 0, 1991, 1992, 1, 0, 0, + 0, 1992, 2059, 3, 878, 439, 0, 1993, 1999, 3, 80, 40, 0, 1994, 1996, 5, + 23, 0, 0, 1995, 1997, 5, 626, 0, 0, 1996, 1995, 1, 0, 0, 0, 1996, 1997, + 1, 0, 0, 0, 1997, 1999, 1, 0, 0, 0, 1998, 1993, 1, 0, 0, 0, 1998, 1994, + 1, 0, 0, 0, 1999, 2000, 1, 0, 0, 0, 2000, 2008, 5, 553, 0, 0, 2001, 2002, + 5, 757, 0, 0, 2002, 2009, 3, 834, 417, 0, 2003, 2004, 5, 23, 0, 0, 2004, + 2005, 5, 758, 0, 0, 2005, 2006, 5, 380, 0, 0, 2006, 2007, 5, 207, 0, 0, + 2007, 2009, 3, 856, 428, 0, 2008, 2001, 1, 0, 0, 0, 2008, 2003, 1, 0, 0, + 0, 2009, 2059, 1, 0, 0, 0, 2010, 2016, 3, 80, 40, 0, 2011, 2013, 5, 23, + 0, 0, 2012, 2014, 5, 626, 0, 0, 2013, 2012, 1, 0, 0, 0, 2013, 2014, 1, + 0, 0, 0, 2014, 2016, 1, 0, 0, 0, 2015, 2010, 1, 0, 0, 0, 2015, 2011, 1, + 0, 0, 0, 2016, 2017, 1, 0, 0, 0, 2017, 2018, 5, 553, 0, 0, 2018, 2019, + 5, 333, 0, 0, 2019, 2020, 5, 758, 0, 0, 2020, 2021, 5, 380, 0, 0, 2021, + 2059, 5, 207, 0, 0, 2022, 2028, 3, 84, 42, 0, 2023, 2025, 5, 23, 0, 0, + 2024, 2026, 5, 626, 0, 0, 2025, 2024, 1, 0, 0, 0, 2025, 2026, 1, 0, 0, + 0, 2026, 2028, 1, 0, 0, 0, 2027, 2022, 1, 0, 0, 0, 2027, 2023, 1, 0, 0, + 0, 2028, 2029, 1, 0, 0, 0, 2029, 2039, 5, 553, 0, 0, 2030, 2031, 3, 836, + 418, 0, 2031, 2032, 3, 878, 439, 0, 2032, 2040, 1, 0, 0, 0, 2033, 2034, + 5, 23, 0, 0, 2034, 2035, 3, 550, 275, 0, 2035, 2036, 5, 380, 0, 0, 2036, + 2037, 5, 757, 0, 0, 2037, 2038, 3, 834, 417, 0, 2038, 2040, 1, 0, 0, 0, + 2039, 2030, 1, 0, 0, 0, 2039, 2033, 1, 0, 0, 0, 2040, 2059, 1, 0, 0, 0, + 2041, 2047, 3, 84, 42, 0, 2042, 2044, 5, 23, 0, 0, 2043, 2045, 5, 626, + 0, 0, 2044, 2043, 1, 0, 0, 0, 2044, 2045, 1, 0, 0, 0, 2045, 2047, 1, 0, + 0, 0, 2046, 2041, 1, 0, 0, 0, 2046, 2042, 1, 0, 0, 0, 2047, 2048, 1, 0, + 0, 0, 2048, 2049, 5, 553, 0, 0, 2049, 2050, 5, 333, 0, 0, 2050, 2051, 3, + 550, 275, 0, 2051, 2056, 5, 380, 0, 0, 2052, 2053, 5, 207, 0, 0, 2053, + 2057, 3, 856, 428, 0, 2054, 2055, 5, 757, 0, 0, 2055, 2057, 3, 834, 417, + 0, 2056, 2052, 1, 0, 0, 0, 2056, 2054, 1, 0, 0, 0, 2057, 2059, 1, 0, 0, + 0, 2058, 1973, 1, 0, 0, 0, 2058, 1982, 1, 0, 0, 0, 2058, 1998, 1, 0, 0, + 0, 2058, 2015, 1, 0, 0, 0, 2058, 2027, 1, 0, 0, 0, 2058, 2046, 1, 0, 0, + 0, 2059, 2060, 1, 0, 0, 0, 2060, 2062, 5, 329, 0, 0, 2061, 2063, 5, 718, + 0, 0, 2062, 2061, 1, 0, 0, 0, 2062, 2063, 1, 0, 0, 0, 2063, 2064, 1, 0, + 0, 0, 2064, 2066, 3, 856, 428, 0, 2065, 2067, 3, 618, 309, 0, 2066, 2065, + 1, 0, 0, 0, 2066, 2067, 1, 0, 0, 0, 2067, 109, 1, 0, 0, 0, 2068, 2069, + 5, 714, 0, 0, 2069, 2070, 3, 90, 45, 0, 2070, 2093, 5, 553, 0, 0, 2071, + 2072, 5, 207, 0, 0, 2072, 2094, 3, 856, 428, 0, 2073, 2074, 5, 757, 0, + 0, 2074, 2094, 3, 834, 417, 0, 2075, 2076, 5, 880, 0, 0, 2076, 2083, 3, + 878, 439, 0, 2077, 2078, 5, 23, 0, 0, 2078, 2079, 5, 883, 0, 0, 2079, 2080, + 5, 380, 0, 0, 2080, 2081, 5, 757, 0, 0, 2081, 2083, 3, 834, 417, 0, 2082, + 2075, 1, 0, 0, 0, 2082, 2077, 1, 0, 0, 0, 2083, 2094, 1, 0, 0, 0, 2084, + 2085, 5, 1005, 0, 0, 2085, 2092, 3, 878, 439, 0, 2086, 2087, 5, 23, 0, + 0, 2087, 2088, 5, 1006, 0, 0, 2088, 2089, 5, 380, 0, 0, 2089, 2090, 5, + 757, 0, 0, 2090, 2092, 3, 834, 417, 0, 2091, 2084, 1, 0, 0, 0, 2091, 2086, + 1, 0, 0, 0, 2092, 2094, 1, 0, 0, 0, 2093, 2071, 1, 0, 0, 0, 2093, 2073, + 1, 0, 0, 0, 2093, 2082, 1, 0, 0, 0, 2093, 2091, 1, 0, 0, 0, 2094, 2095, + 1, 0, 0, 0, 2095, 2096, 5, 329, 0, 0, 2096, 2097, 5, 786, 0, 0, 2097, 2098, + 3, 856, 428, 0, 2098, 111, 1, 0, 0, 0, 2099, 2100, 5, 714, 0, 0, 2100, + 2101, 5, 718, 0, 0, 2101, 2102, 3, 94, 47, 0, 2102, 2107, 5, 329, 0, 0, + 2103, 2104, 5, 718, 0, 0, 2104, 2108, 3, 94, 47, 0, 2105, 2106, 5, 984, + 0, 0, 2106, 2108, 3, 856, 428, 0, 2107, 2103, 1, 0, 0, 0, 2107, 2105, 1, + 0, 0, 0, 2108, 113, 1, 0, 0, 0, 2109, 2111, 5, 720, 0, 0, 2110, 2112, 5, + 1024, 0, 0, 2111, 2110, 1, 0, 0, 0, 2111, 2112, 1, 0, 0, 0, 2112, 115, + 1, 0, 0, 0, 2113, 2114, 5, 783, 0, 0, 2114, 2115, 3, 856, 428, 0, 2115, + 2116, 5, 1092, 0, 0, 2116, 2117, 3, 886, 443, 0, 2117, 2142, 1, 0, 0, 0, + 2118, 2119, 5, 783, 0, 0, 2119, 2120, 5, 1104, 0, 0, 2120, 2125, 3, 856, + 428, 0, 2121, 2122, 5, 1110, 0, 0, 2122, 2124, 3, 856, 428, 0, 2123, 2121, + 1, 0, 0, 0, 2124, 2127, 1, 0, 0, 0, 2125, 2123, 1, 0, 0, 0, 2125, 2126, + 1, 0, 0, 0, 2126, 2128, 1, 0, 0, 0, 2127, 2125, 1, 0, 0, 0, 2128, 2129, + 5, 1105, 0, 0, 2129, 2130, 5, 1092, 0, 0, 2130, 2131, 5, 1104, 0, 0, 2131, + 2136, 3, 886, 443, 0, 2132, 2133, 5, 1110, 0, 0, 2133, 2135, 3, 886, 443, + 0, 2134, 2132, 1, 0, 0, 0, 2135, 2138, 1, 0, 0, 0, 2136, 2134, 1, 0, 0, + 0, 2136, 2137, 1, 0, 0, 0, 2137, 2139, 1, 0, 0, 0, 2138, 2136, 1, 0, 0, + 0, 2139, 2140, 5, 1105, 0, 0, 2140, 2142, 1, 0, 0, 0, 2141, 2113, 1, 0, + 0, 0, 2141, 2118, 1, 0, 0, 0, 2142, 117, 1, 0, 0, 0, 2143, 2144, 5, 945, + 0, 0, 2144, 2145, 5, 463, 0, 0, 2145, 2146, 5, 1005, 0, 0, 2146, 2147, + 3, 878, 439, 0, 2147, 119, 1, 0, 0, 0, 2148, 2150, 5, 945, 0, 0, 2149, + 2151, 5, 880, 0, 0, 2150, 2149, 1, 0, 0, 0, 2150, 2151, 1, 0, 0, 0, 2151, + 2153, 1, 0, 0, 0, 2152, 2154, 3, 650, 325, 0, 2153, 2152, 1, 0, 0, 0, 2153, + 2154, 1, 0, 0, 0, 2154, 2155, 1, 0, 0, 0, 2155, 2156, 3, 878, 439, 0, 2156, + 121, 1, 0, 0, 0, 2157, 2158, 5, 974, 0, 0, 2158, 2172, 3, 856, 428, 0, + 2159, 2160, 5, 974, 0, 0, 2160, 2161, 5, 1104, 0, 0, 2161, 2166, 3, 856, + 428, 0, 2162, 2163, 5, 1110, 0, 0, 2163, 2165, 3, 856, 428, 0, 2164, 2162, + 1, 0, 0, 0, 2165, 2168, 1, 0, 0, 0, 2166, 2164, 1, 0, 0, 0, 2166, 2167, + 1, 0, 0, 0, 2167, 2169, 1, 0, 0, 0, 2168, 2166, 1, 0, 0, 0, 2169, 2170, + 5, 1105, 0, 0, 2170, 2172, 1, 0, 0, 0, 2171, 2157, 1, 0, 0, 0, 2171, 2159, + 1, 0, 0, 0, 2172, 123, 1, 0, 0, 0, 2173, 2214, 3, 136, 68, 0, 2174, 2214, + 3, 140, 70, 0, 2175, 2214, 3, 148, 74, 0, 2176, 2214, 3, 152, 76, 0, 2177, + 2214, 3, 154, 77, 0, 2178, 2214, 3, 160, 80, 0, 2179, 2214, 3, 162, 81, + 0, 2180, 2214, 3, 174, 87, 0, 2181, 2214, 3, 176, 88, 0, 2182, 2214, 3, + 178, 89, 0, 2183, 2214, 3, 184, 92, 0, 2184, 2214, 3, 186, 93, 0, 2185, + 2214, 3, 188, 94, 0, 2186, 2214, 3, 190, 95, 0, 2187, 2214, 3, 192, 96, + 0, 2188, 2214, 3, 194, 97, 0, 2189, 2214, 3, 196, 98, 0, 2190, 2214, 3, + 206, 103, 0, 2191, 2214, 3, 208, 104, 0, 2192, 2214, 3, 210, 105, 0, 2193, + 2214, 3, 212, 106, 0, 2194, 2214, 3, 216, 108, 0, 2195, 2214, 3, 218, 109, + 0, 2196, 2214, 3, 222, 111, 0, 2197, 2214, 3, 226, 113, 0, 2198, 2214, + 3, 228, 114, 0, 2199, 2214, 3, 232, 116, 0, 2200, 2214, 3, 234, 117, 0, + 2201, 2214, 3, 236, 118, 0, 2202, 2214, 3, 238, 119, 0, 2203, 2214, 3, + 240, 120, 0, 2204, 2214, 3, 242, 121, 0, 2205, 2214, 3, 244, 122, 0, 2206, + 2214, 3, 246, 123, 0, 2207, 2214, 3, 264, 132, 0, 2208, 2214, 3, 276, 138, + 0, 2209, 2214, 3, 278, 139, 0, 2210, 2214, 3, 280, 140, 0, 2211, 2214, + 3, 282, 141, 0, 2212, 2214, 3, 286, 143, 0, 2213, 2173, 1, 0, 0, 0, 2213, + 2174, 1, 0, 0, 0, 2213, 2175, 1, 0, 0, 0, 2213, 2176, 1, 0, 0, 0, 2213, + 2177, 1, 0, 0, 0, 2213, 2178, 1, 0, 0, 0, 2213, 2179, 1, 0, 0, 0, 2213, + 2180, 1, 0, 0, 0, 2213, 2181, 1, 0, 0, 0, 2213, 2182, 1, 0, 0, 0, 2213, + 2183, 1, 0, 0, 0, 2213, 2184, 1, 0, 0, 0, 2213, 2185, 1, 0, 0, 0, 2213, + 2186, 1, 0, 0, 0, 2213, 2187, 1, 0, 0, 0, 2213, 2188, 1, 0, 0, 0, 2213, + 2189, 1, 0, 0, 0, 2213, 2190, 1, 0, 0, 0, 2213, 2191, 1, 0, 0, 0, 2213, + 2192, 1, 0, 0, 0, 2213, 2193, 1, 0, 0, 0, 2213, 2194, 1, 0, 0, 0, 2213, + 2195, 1, 0, 0, 0, 2213, 2196, 1, 0, 0, 0, 2213, 2197, 1, 0, 0, 0, 2213, + 2198, 1, 0, 0, 0, 2213, 2199, 1, 0, 0, 0, 2213, 2200, 1, 0, 0, 0, 2213, + 2201, 1, 0, 0, 0, 2213, 2202, 1, 0, 0, 0, 2213, 2203, 1, 0, 0, 0, 2213, + 2204, 1, 0, 0, 0, 2213, 2205, 1, 0, 0, 0, 2213, 2206, 1, 0, 0, 0, 2213, + 2207, 1, 0, 0, 0, 2213, 2208, 1, 0, 0, 0, 2213, 2209, 1, 0, 0, 0, 2213, + 2210, 1, 0, 0, 0, 2213, 2211, 1, 0, 0, 0, 2213, 2212, 1, 0, 0, 0, 2214, + 125, 1, 0, 0, 0, 2215, 2216, 5, 34, 0, 0, 2216, 2217, 5, 1092, 0, 0, 2217, + 2258, 3, 450, 225, 0, 2218, 2219, 5, 139, 0, 0, 2219, 2220, 5, 1092, 0, + 0, 2220, 2258, 3, 880, 440, 0, 2221, 2222, 5, 271, 0, 0, 2222, 2223, 5, + 1092, 0, 0, 2223, 2258, 3, 450, 225, 0, 2224, 2225, 5, 293, 0, 0, 2225, + 2226, 5, 1092, 0, 0, 2226, 2258, 3, 450, 225, 0, 2227, 2228, 5, 387, 0, + 0, 2228, 2229, 5, 1092, 0, 0, 2229, 2258, 3, 880, 440, 0, 2230, 2231, 5, + 497, 0, 0, 2231, 2232, 5, 1092, 0, 0, 2232, 2258, 3, 852, 426, 0, 2233, + 2234, 5, 596, 0, 0, 2234, 2235, 5, 1092, 0, 0, 2235, 2258, 3, 450, 225, + 0, 2236, 2237, 5, 616, 0, 0, 2237, 2238, 5, 1092, 0, 0, 2238, 2258, 3, + 450, 225, 0, 2239, 2240, 5, 617, 0, 0, 2240, 2241, 5, 1092, 0, 0, 2241, + 2258, 3, 450, 225, 0, 2242, 2243, 5, 691, 0, 0, 2243, 2244, 5, 1092, 0, + 0, 2244, 2258, 3, 450, 225, 0, 2245, 2246, 5, 692, 0, 0, 2246, 2247, 5, + 1092, 0, 0, 2247, 2258, 3, 450, 225, 0, 2248, 2249, 5, 751, 0, 0, 2249, + 2250, 5, 1092, 0, 0, 2250, 2258, 3, 894, 447, 0, 2251, 2252, 5, 781, 0, + 0, 2252, 2253, 5, 1092, 0, 0, 2253, 2258, 3, 852, 426, 0, 2254, 2255, 5, + 821, 0, 0, 2255, 2256, 5, 1092, 0, 0, 2256, 2258, 3, 450, 225, 0, 2257, + 2215, 1, 0, 0, 0, 2257, 2218, 1, 0, 0, 0, 2257, 2221, 1, 0, 0, 0, 2257, + 2224, 1, 0, 0, 0, 2257, 2227, 1, 0, 0, 0, 2257, 2230, 1, 0, 0, 0, 2257, + 2233, 1, 0, 0, 0, 2257, 2236, 1, 0, 0, 0, 2257, 2239, 1, 0, 0, 0, 2257, + 2242, 1, 0, 0, 0, 2257, 2245, 1, 0, 0, 0, 2257, 2248, 1, 0, 0, 0, 2257, + 2251, 1, 0, 0, 0, 2257, 2254, 1, 0, 0, 0, 2258, 127, 1, 0, 0, 0, 2259, + 2260, 5, 209, 0, 0, 2260, 2261, 5, 1092, 0, 0, 2261, 2285, 3, 880, 440, + 0, 2262, 2263, 5, 467, 0, 0, 2263, 2264, 5, 1092, 0, 0, 2264, 2285, 3, + 880, 440, 0, 2265, 2285, 3, 130, 65, 0, 2266, 2267, 5, 466, 0, 0, 2267, + 2268, 5, 1092, 0, 0, 2268, 2285, 3, 880, 440, 0, 2269, 2270, 5, 497, 0, + 0, 2270, 2271, 5, 1092, 0, 0, 2271, 2285, 3, 852, 426, 0, 2272, 2273, 5, + 603, 0, 0, 2273, 2274, 5, 1092, 0, 0, 2274, 2285, 3, 450, 225, 0, 2275, + 2276, 5, 781, 0, 0, 2276, 2277, 5, 1092, 0, 0, 2277, 2285, 3, 852, 426, + 0, 2278, 2279, 5, 835, 0, 0, 2279, 2280, 5, 1092, 0, 0, 2280, 2285, 3, + 880, 440, 0, 2281, 2282, 5, 836, 0, 0, 2282, 2283, 5, 1092, 0, 0, 2283, + 2285, 3, 880, 440, 0, 2284, 2259, 1, 0, 0, 0, 2284, 2262, 1, 0, 0, 0, 2284, + 2265, 1, 0, 0, 0, 2284, 2266, 1, 0, 0, 0, 2284, 2269, 1, 0, 0, 0, 2284, + 2272, 1, 0, 0, 0, 2284, 2275, 1, 0, 0, 0, 2284, 2278, 1, 0, 0, 0, 2284, + 2281, 1, 0, 0, 0, 2285, 129, 1, 0, 0, 0, 2286, 2287, 5, 222, 0, 0, 2287, + 2288, 5, 1092, 0, 0, 2288, 2289, 3, 852, 426, 0, 2289, 131, 1, 0, 0, 0, + 2290, 2291, 5, 587, 0, 0, 2291, 2292, 5, 1092, 0, 0, 2292, 2343, 3, 852, + 426, 0, 2293, 2294, 5, 445, 0, 0, 2294, 2295, 5, 1092, 0, 0, 2295, 2343, + 3, 852, 426, 0, 2296, 2297, 5, 244, 0, 0, 2297, 2298, 5, 1092, 0, 0, 2298, + 2343, 3, 852, 426, 0, 2299, 2300, 5, 320, 0, 0, 2300, 2301, 5, 1092, 0, + 0, 2301, 2343, 3, 852, 426, 0, 2302, 2303, 5, 473, 0, 0, 2303, 2304, 5, + 1092, 0, 0, 2304, 2343, 3, 852, 426, 0, 2305, 2306, 5, 421, 0, 0, 2306, + 2307, 5, 1092, 0, 0, 2307, 2343, 3, 852, 426, 0, 2308, 2309, 5, 254, 0, + 0, 2309, 2310, 5, 1092, 0, 0, 2310, 2343, 3, 852, 426, 0, 2311, 2312, 5, + 491, 0, 0, 2312, 2313, 5, 1092, 0, 0, 2313, 2343, 3, 450, 225, 0, 2314, + 2315, 5, 240, 0, 0, 2315, 2316, 5, 1092, 0, 0, 2316, 2343, 3, 450, 225, + 0, 2317, 2318, 5, 219, 0, 0, 2318, 2319, 5, 1092, 0, 0, 2319, 2343, 3, + 880, 440, 0, 2320, 2321, 5, 476, 0, 0, 2321, 2322, 5, 1092, 0, 0, 2322, + 2343, 3, 880, 440, 0, 2323, 2324, 5, 225, 0, 0, 2324, 2325, 5, 1092, 0, + 0, 2325, 2343, 3, 852, 426, 0, 2326, 2327, 5, 223, 0, 0, 2327, 2328, 5, + 1092, 0, 0, 2328, 2343, 3, 852, 426, 0, 2329, 2330, 5, 224, 0, 0, 2330, + 2331, 5, 1092, 0, 0, 2331, 2343, 3, 852, 426, 0, 2332, 2333, 5, 475, 0, + 0, 2333, 2334, 5, 1092, 0, 0, 2334, 2343, 3, 880, 440, 0, 2335, 2336, 5, + 730, 0, 0, 2336, 2337, 5, 1092, 0, 0, 2337, 2343, 3, 852, 426, 0, 2338, + 2339, 5, 731, 0, 0, 2339, 2340, 5, 1092, 0, 0, 2340, 2343, 3, 852, 426, + 0, 2341, 2343, 3, 646, 323, 0, 2342, 2290, 1, 0, 0, 0, 2342, 2293, 1, 0, + 0, 0, 2342, 2296, 1, 0, 0, 0, 2342, 2299, 1, 0, 0, 0, 2342, 2302, 1, 0, + 0, 0, 2342, 2305, 1, 0, 0, 0, 2342, 2308, 1, 0, 0, 0, 2342, 2311, 1, 0, + 0, 0, 2342, 2314, 1, 0, 0, 0, 2342, 2317, 1, 0, 0, 0, 2342, 2320, 1, 0, + 0, 0, 2342, 2323, 1, 0, 0, 0, 2342, 2326, 1, 0, 0, 0, 2342, 2329, 1, 0, + 0, 0, 2342, 2332, 1, 0, 0, 0, 2342, 2335, 1, 0, 0, 0, 2342, 2338, 1, 0, + 0, 0, 2342, 2341, 1, 0, 0, 0, 2343, 133, 1, 0, 0, 0, 2344, 2345, 5, 4, + 0, 0, 2345, 2346, 5, 1092, 0, 0, 2346, 2438, 3, 450, 225, 0, 2347, 2348, + 5, 64, 0, 0, 2348, 2349, 5, 1092, 0, 0, 2349, 2438, 3, 450, 225, 0, 2350, + 2351, 5, 100, 0, 0, 2351, 2352, 5, 1092, 0, 0, 2352, 2438, 3, 852, 426, + 0, 2353, 2354, 5, 101, 0, 0, 2354, 2355, 5, 1092, 0, 0, 2355, 2438, 3, + 852, 426, 0, 2356, 2357, 5, 215, 0, 0, 2357, 2358, 5, 1092, 0, 0, 2358, + 2438, 3, 852, 426, 0, 2359, 2360, 5, 216, 0, 0, 2360, 2361, 5, 1092, 0, + 0, 2361, 2438, 3, 852, 426, 0, 2362, 2363, 5, 276, 0, 0, 2363, 2364, 5, + 1092, 0, 0, 2364, 2438, 3, 450, 225, 0, 2365, 2366, 5, 277, 0, 0, 2366, + 2367, 5, 1092, 0, 0, 2367, 2438, 3, 450, 225, 0, 2368, 2369, 5, 409, 0, + 0, 2369, 2370, 5, 1092, 0, 0, 2370, 2438, 3, 880, 440, 0, 2371, 2372, 5, + 442, 0, 0, 2372, 2373, 5, 1092, 0, 0, 2373, 2438, 3, 880, 440, 0, 2374, + 2375, 5, 644, 0, 0, 2375, 2376, 5, 1092, 0, 0, 2376, 2438, 3, 852, 426, + 0, 2377, 2378, 5, 728, 0, 0, 2378, 2379, 5, 1092, 0, 0, 2379, 2438, 3, + 880, 440, 0, 2380, 2381, 5, 798, 0, 0, 2381, 2382, 5, 1092, 0, 0, 2382, + 2438, 3, 852, 426, 0, 2383, 2384, 5, 836, 0, 0, 2384, 2385, 5, 1092, 0, + 0, 2385, 2438, 3, 880, 440, 0, 2386, 2387, 5, 860, 0, 0, 2387, 2388, 5, + 1092, 0, 0, 2388, 2438, 3, 450, 225, 0, 2389, 2390, 5, 905, 0, 0, 2390, + 2391, 5, 1092, 0, 0, 2391, 2438, 3, 450, 225, 0, 2392, 2393, 5, 907, 0, + 0, 2393, 2394, 5, 1092, 0, 0, 2394, 2438, 3, 852, 426, 0, 2395, 2396, 5, + 909, 0, 0, 2396, 2397, 5, 1092, 0, 0, 2397, 2438, 3, 852, 426, 0, 2398, + 2399, 5, 911, 0, 0, 2399, 2400, 5, 1092, 0, 0, 2400, 2438, 3, 852, 426, + 0, 2401, 2402, 5, 912, 0, 0, 2402, 2403, 5, 1092, 0, 0, 2403, 2438, 3, + 852, 426, 0, 2404, 2405, 5, 913, 0, 0, 2405, 2406, 5, 1092, 0, 0, 2406, + 2438, 3, 852, 426, 0, 2407, 2408, 5, 915, 0, 0, 2408, 2409, 5, 1092, 0, + 0, 2409, 2438, 3, 852, 426, 0, 2410, 2411, 5, 918, 0, 0, 2411, 2412, 5, + 1092, 0, 0, 2412, 2438, 3, 852, 426, 0, 2413, 2414, 5, 920, 0, 0, 2414, + 2415, 5, 1092, 0, 0, 2415, 2438, 3, 852, 426, 0, 2416, 2417, 5, 921, 0, + 0, 2417, 2418, 5, 1092, 0, 0, 2418, 2438, 3, 852, 426, 0, 2419, 2420, 5, + 933, 0, 0, 2420, 2421, 5, 1092, 0, 0, 2421, 2438, 3, 852, 426, 0, 2422, + 2423, 5, 952, 0, 0, 2423, 2424, 5, 1092, 0, 0, 2424, 2438, 3, 880, 440, + 0, 2425, 2426, 5, 975, 0, 0, 2426, 2427, 5, 1092, 0, 0, 2427, 2438, 3, + 852, 426, 0, 2428, 2429, 5, 991, 0, 0, 2429, 2430, 5, 1092, 0, 0, 2430, + 2438, 3, 450, 225, 0, 2431, 2432, 5, 1015, 0, 0, 2432, 2433, 5, 1092, 0, + 0, 2433, 2438, 3, 880, 440, 0, 2434, 2435, 5, 1016, 0, 0, 2435, 2436, 5, + 1092, 0, 0, 2436, 2438, 3, 880, 440, 0, 2437, 2344, 1, 0, 0, 0, 2437, 2347, + 1, 0, 0, 0, 2437, 2350, 1, 0, 0, 0, 2437, 2353, 1, 0, 0, 0, 2437, 2356, + 1, 0, 0, 0, 2437, 2359, 1, 0, 0, 0, 2437, 2362, 1, 0, 0, 0, 2437, 2365, + 1, 0, 0, 0, 2437, 2368, 1, 0, 0, 0, 2437, 2371, 1, 0, 0, 0, 2437, 2374, + 1, 0, 0, 0, 2437, 2377, 1, 0, 0, 0, 2437, 2380, 1, 0, 0, 0, 2437, 2383, + 1, 0, 0, 0, 2437, 2386, 1, 0, 0, 0, 2437, 2389, 1, 0, 0, 0, 2437, 2392, + 1, 0, 0, 0, 2437, 2395, 1, 0, 0, 0, 2437, 2398, 1, 0, 0, 0, 2437, 2401, + 1, 0, 0, 0, 2437, 2404, 1, 0, 0, 0, 2437, 2407, 1, 0, 0, 0, 2437, 2410, + 1, 0, 0, 0, 2437, 2413, 1, 0, 0, 0, 2437, 2416, 1, 0, 0, 0, 2437, 2419, + 1, 0, 0, 0, 2437, 2422, 1, 0, 0, 0, 2437, 2425, 1, 0, 0, 0, 2437, 2428, + 1, 0, 0, 0, 2437, 2431, 1, 0, 0, 0, 2437, 2434, 1, 0, 0, 0, 2438, 135, + 1, 0, 0, 0, 2439, 2440, 5, 38, 0, 0, 2440, 2441, 5, 9, 0, 0, 2441, 2442, + 3, 298, 149, 0, 2442, 137, 1, 0, 0, 0, 2443, 2444, 5, 258, 0, 0, 2444, + 2445, 5, 1092, 0, 0, 2445, 2446, 3, 450, 225, 0, 2446, 139, 1, 0, 0, 0, + 2447, 2448, 5, 38, 0, 0, 2448, 2450, 5, 21, 0, 0, 2449, 2451, 3, 650, 325, + 0, 2450, 2449, 1, 0, 0, 0, 2450, 2451, 1, 0, 0, 0, 2451, 2452, 1, 0, 0, + 0, 2452, 2476, 3, 856, 428, 0, 2453, 2477, 3, 142, 71, 0, 2454, 2456, 5, + 783, 0, 0, 2455, 2457, 3, 144, 72, 0, 2456, 2455, 1, 0, 0, 0, 2457, 2458, + 1, 0, 0, 0, 2458, 2456, 1, 0, 0, 0, 2458, 2459, 1, 0, 0, 0, 2459, 2477, + 1, 0, 0, 0, 2460, 2462, 5, 974, 0, 0, 2461, 2463, 3, 146, 73, 0, 2462, + 2461, 1, 0, 0, 0, 2463, 2464, 1, 0, 0, 0, 2464, 2462, 1, 0, 0, 0, 2464, + 2465, 1, 0, 0, 0, 2465, 2477, 1, 0, 0, 0, 2466, 2467, 5, 483, 0, 0, 2467, + 2468, 5, 169, 0, 0, 2468, 2469, 5, 285, 0, 0, 2469, 2470, 5, 1104, 0, 0, + 2470, 2471, 3, 312, 156, 0, 2471, 2472, 5, 1105, 0, 0, 2472, 2477, 1, 0, + 0, 0, 2473, 2474, 5, 483, 0, 0, 2474, 2475, 5, 12, 0, 0, 2475, 2477, 3, + 314, 157, 0, 2476, 2453, 1, 0, 0, 0, 2476, 2454, 1, 0, 0, 0, 2476, 2460, + 1, 0, 0, 0, 2476, 2466, 1, 0, 0, 0, 2476, 2473, 1, 0, 0, 0, 2477, 141, + 1, 0, 0, 0, 2478, 2479, 7, 10, 0, 0, 2479, 143, 1, 0, 0, 0, 2480, 2481, + 5, 1011, 0, 0, 2481, 2482, 5, 1092, 0, 0, 2482, 2488, 3, 856, 428, 0, 2483, + 2484, 5, 755, 0, 0, 2484, 2485, 5, 1092, 0, 0, 2485, 2488, 3, 852, 426, + 0, 2486, 2488, 3, 646, 323, 0, 2487, 2480, 1, 0, 0, 0, 2487, 2483, 1, 0, + 0, 0, 2487, 2486, 1, 0, 0, 0, 2488, 145, 1, 0, 0, 0, 2489, 2490, 7, 11, + 0, 0, 2490, 147, 1, 0, 0, 0, 2491, 2493, 5, 38, 0, 0, 2492, 2494, 5, 44, + 0, 0, 2493, 2492, 1, 0, 0, 0, 2493, 2494, 1, 0, 0, 0, 2494, 2495, 1, 0, + 0, 0, 2495, 2497, 5, 394, 0, 0, 2496, 2498, 3, 650, 325, 0, 2497, 2496, + 1, 0, 0, 0, 2497, 2498, 1, 0, 0, 0, 2498, 2499, 1, 0, 0, 0, 2499, 2500, + 3, 856, 428, 0, 2500, 2504, 5, 783, 0, 0, 2501, 2502, 5, 46, 0, 0, 2502, + 2503, 5, 1092, 0, 0, 2503, 2505, 3, 852, 426, 0, 2504, 2501, 1, 0, 0, 0, + 2504, 2505, 1, 0, 0, 0, 2505, 2509, 1, 0, 0, 0, 2506, 2507, 5, 85, 0, 0, + 2507, 2508, 5, 1092, 0, 0, 2508, 2510, 3, 852, 426, 0, 2509, 2506, 1, 0, + 0, 0, 2509, 2510, 1, 0, 0, 0, 2510, 2514, 1, 0, 0, 0, 2511, 2512, 5, 49, + 0, 0, 2512, 2513, 5, 1092, 0, 0, 2513, 2515, 3, 852, 426, 0, 2514, 2511, + 1, 0, 0, 0, 2514, 2515, 1, 0, 0, 0, 2515, 2517, 1, 0, 0, 0, 2516, 2518, + 3, 138, 69, 0, 2517, 2516, 1, 0, 0, 0, 2517, 2518, 1, 0, 0, 0, 2518, 2525, + 1, 0, 0, 0, 2519, 2520, 5, 45, 0, 0, 2520, 2521, 5, 1092, 0, 0, 2521, 2522, + 5, 1104, 0, 0, 2522, 2523, 3, 852, 426, 0, 2523, 2524, 5, 1105, 0, 0, 2524, + 2526, 1, 0, 0, 0, 2525, 2519, 1, 0, 0, 0, 2525, 2526, 1, 0, 0, 0, 2526, + 2533, 1, 0, 0, 0, 2527, 2528, 5, 47, 0, 0, 2528, 2529, 5, 1092, 0, 0, 2529, + 2530, 5, 1104, 0, 0, 2530, 2531, 3, 852, 426, 0, 2531, 2532, 5, 1105, 0, + 0, 2532, 2534, 1, 0, 0, 0, 2533, 2527, 1, 0, 0, 0, 2533, 2534, 1, 0, 0, + 0, 2534, 2536, 1, 0, 0, 0, 2535, 2537, 3, 646, 323, 0, 2536, 2535, 1, 0, + 0, 0, 2536, 2537, 1, 0, 0, 0, 2537, 2573, 1, 0, 0, 0, 2538, 2540, 5, 38, + 0, 0, 2539, 2541, 5, 44, 0, 0, 2540, 2539, 1, 0, 0, 0, 2540, 2541, 1, 0, + 0, 0, 2541, 2542, 1, 0, 0, 0, 2542, 2543, 5, 394, 0, 0, 2543, 2544, 3, + 856, 428, 0, 2544, 2545, 3, 300, 150, 0, 2545, 2573, 1, 0, 0, 0, 2546, + 2548, 5, 38, 0, 0, 2547, 2549, 5, 44, 0, 0, 2548, 2547, 1, 0, 0, 0, 2548, + 2549, 1, 0, 0, 0, 2549, 2550, 1, 0, 0, 0, 2550, 2551, 5, 394, 0, 0, 2551, + 2552, 3, 856, 428, 0, 2552, 2553, 3, 304, 152, 0, 2553, 2573, 1, 0, 0, + 0, 2554, 2556, 5, 38, 0, 0, 2555, 2557, 5, 44, 0, 0, 2556, 2555, 1, 0, + 0, 0, 2556, 2557, 1, 0, 0, 0, 2557, 2558, 1, 0, 0, 0, 2558, 2560, 5, 394, + 0, 0, 2559, 2561, 3, 650, 325, 0, 2560, 2559, 1, 0, 0, 0, 2560, 2561, 1, + 0, 0, 0, 2561, 2562, 1, 0, 0, 0, 2562, 2563, 3, 856, 428, 0, 2563, 2564, + 5, 974, 0, 0, 2564, 2569, 3, 150, 75, 0, 2565, 2566, 5, 1110, 0, 0, 2566, + 2568, 3, 150, 75, 0, 2567, 2565, 1, 0, 0, 0, 2568, 2571, 1, 0, 0, 0, 2569, + 2567, 1, 0, 0, 0, 2569, 2570, 1, 0, 0, 0, 2570, 2573, 1, 0, 0, 0, 2571, + 2569, 1, 0, 0, 0, 2572, 2491, 1, 0, 0, 0, 2572, 2538, 1, 0, 0, 0, 2572, + 2546, 1, 0, 0, 0, 2572, 2554, 1, 0, 0, 0, 2573, 149, 1, 0, 0, 0, 2574, + 2575, 7, 12, 0, 0, 2575, 151, 1, 0, 0, 0, 2576, 2577, 5, 38, 0, 0, 2577, + 2578, 5, 172, 0, 0, 2578, 2579, 3, 288, 144, 0, 2579, 153, 1, 0, 0, 0, + 2580, 2581, 5, 38, 0, 0, 2581, 2583, 5, 207, 0, 0, 2582, 2584, 3, 650, + 325, 0, 2583, 2582, 1, 0, 0, 0, 2583, 2584, 1, 0, 0, 0, 2584, 2585, 1, + 0, 0, 0, 2585, 2586, 3, 856, 428, 0, 2586, 2587, 5, 682, 0, 0, 2587, 2588, + 5, 922, 0, 0, 2588, 2589, 3, 856, 428, 0, 2589, 2701, 1, 0, 0, 0, 2590, + 2591, 5, 38, 0, 0, 2591, 2593, 5, 207, 0, 0, 2592, 2594, 3, 650, 325, 0, + 2593, 2592, 1, 0, 0, 0, 2593, 2594, 1, 0, 0, 0, 2594, 2595, 1, 0, 0, 0, + 2595, 2596, 3, 856, 428, 0, 2596, 2597, 5, 874, 0, 0, 2597, 2598, 5, 1020, + 0, 0, 2598, 2599, 3, 856, 428, 0, 2599, 2701, 1, 0, 0, 0, 2600, 2601, 5, + 38, 0, 0, 2601, 2603, 5, 207, 0, 0, 2602, 2604, 3, 650, 325, 0, 2603, 2602, + 1, 0, 0, 0, 2603, 2604, 1, 0, 0, 0, 2604, 2605, 1, 0, 0, 0, 2605, 2606, + 3, 856, 428, 0, 2606, 2610, 5, 783, 0, 0, 2607, 2608, 5, 209, 0, 0, 2608, + 2609, 5, 1092, 0, 0, 2609, 2611, 3, 880, 440, 0, 2610, 2607, 1, 0, 0, 0, + 2610, 2611, 1, 0, 0, 0, 2611, 2615, 1, 0, 0, 0, 2612, 2613, 5, 467, 0, + 0, 2613, 2614, 5, 1092, 0, 0, 2614, 2616, 3, 880, 440, 0, 2615, 2612, 1, + 0, 0, 0, 2615, 2616, 1, 0, 0, 0, 2616, 2618, 1, 0, 0, 0, 2617, 2619, 3, + 130, 65, 0, 2618, 2617, 1, 0, 0, 0, 2618, 2619, 1, 0, 0, 0, 2619, 2621, + 1, 0, 0, 0, 2620, 2622, 3, 646, 323, 0, 2621, 2620, 1, 0, 0, 0, 2621, 2622, + 1, 0, 0, 0, 2622, 2701, 1, 0, 0, 0, 2623, 2624, 5, 38, 0, 0, 2624, 2625, + 5, 207, 0, 0, 2625, 2626, 3, 856, 428, 0, 2626, 2627, 3, 300, 150, 0, 2627, + 2701, 1, 0, 0, 0, 2628, 2629, 5, 38, 0, 0, 2629, 2630, 5, 207, 0, 0, 2630, + 2631, 3, 856, 428, 0, 2631, 2632, 3, 304, 152, 0, 2632, 2701, 1, 0, 0, + 0, 2633, 2634, 5, 38, 0, 0, 2634, 2636, 5, 207, 0, 0, 2635, 2637, 3, 650, + 325, 0, 2636, 2635, 1, 0, 0, 0, 2636, 2637, 1, 0, 0, 0, 2637, 2638, 1, + 0, 0, 0, 2638, 2639, 3, 856, 428, 0, 2639, 2640, 5, 974, 0, 0, 2640, 2645, + 3, 156, 78, 0, 2641, 2642, 5, 1110, 0, 0, 2642, 2644, 3, 156, 78, 0, 2643, + 2641, 1, 0, 0, 0, 2644, 2647, 1, 0, 0, 0, 2645, 2643, 1, 0, 0, 0, 2645, + 2646, 1, 0, 0, 0, 2646, 2701, 1, 0, 0, 0, 2647, 2645, 1, 0, 0, 0, 2648, + 2649, 5, 38, 0, 0, 2649, 2650, 5, 207, 0, 0, 2650, 2651, 3, 856, 428, 0, + 2651, 2652, 5, 257, 0, 0, 2652, 2653, 5, 687, 0, 0, 2653, 2654, 5, 922, + 0, 0, 2654, 2655, 5, 11, 0, 0, 2655, 2659, 3, 158, 79, 0, 2656, 2657, 5, + 367, 0, 0, 2657, 2658, 5, 252, 0, 0, 2658, 2660, 5, 131, 0, 0, 2659, 2656, + 1, 0, 0, 0, 2659, 2660, 1, 0, 0, 0, 2660, 2701, 1, 0, 0, 0, 2661, 2662, + 5, 38, 0, 0, 2662, 2663, 5, 207, 0, 0, 2663, 2664, 3, 856, 428, 0, 2664, + 2665, 5, 239, 0, 0, 2665, 2669, 5, 687, 0, 0, 2666, 2667, 5, 922, 0, 0, + 2667, 2668, 5, 11, 0, 0, 2668, 2670, 3, 158, 79, 0, 2669, 2666, 1, 0, 0, + 0, 2669, 2670, 1, 0, 0, 0, 2670, 2701, 1, 0, 0, 0, 2671, 2672, 5, 38, 0, + 0, 2672, 2673, 5, 207, 0, 0, 2673, 2674, 3, 856, 428, 0, 2674, 2675, 5, + 671, 0, 0, 2675, 2701, 1, 0, 0, 0, 2676, 2677, 5, 38, 0, 0, 2677, 2678, + 5, 207, 0, 0, 2678, 2679, 3, 856, 428, 0, 2679, 2680, 5, 257, 0, 0, 2680, + 2681, 5, 307, 0, 0, 2681, 2682, 5, 922, 0, 0, 2682, 2683, 5, 11, 0, 0, + 2683, 2684, 3, 158, 79, 0, 2684, 2701, 1, 0, 0, 0, 2685, 2686, 5, 38, 0, + 0, 2686, 2687, 5, 207, 0, 0, 2687, 2688, 3, 856, 428, 0, 2688, 2689, 5, + 239, 0, 0, 2689, 2693, 5, 307, 0, 0, 2690, 2691, 5, 922, 0, 0, 2691, 2692, + 5, 11, 0, 0, 2692, 2694, 3, 158, 79, 0, 2693, 2690, 1, 0, 0, 0, 2693, 2694, + 1, 0, 0, 0, 2694, 2701, 1, 0, 0, 0, 2695, 2696, 5, 38, 0, 0, 2696, 2697, + 5, 207, 0, 0, 2697, 2698, 3, 856, 428, 0, 2698, 2699, 5, 619, 0, 0, 2699, + 2701, 1, 0, 0, 0, 2700, 2580, 1, 0, 0, 0, 2700, 2590, 1, 0, 0, 0, 2700, + 2600, 1, 0, 0, 0, 2700, 2623, 1, 0, 0, 0, 2700, 2628, 1, 0, 0, 0, 2700, + 2633, 1, 0, 0, 0, 2700, 2648, 1, 0, 0, 0, 2700, 2661, 1, 0, 0, 0, 2700, + 2671, 1, 0, 0, 0, 2700, 2676, 1, 0, 0, 0, 2700, 2685, 1, 0, 0, 0, 2700, + 2695, 1, 0, 0, 0, 2701, 155, 1, 0, 0, 0, 2702, 2703, 7, 13, 0, 0, 2703, + 157, 1, 0, 0, 0, 2704, 2709, 3, 832, 416, 0, 2705, 2706, 5, 1110, 0, 0, + 2706, 2708, 3, 832, 416, 0, 2707, 2705, 1, 0, 0, 0, 2708, 2711, 1, 0, 0, + 0, 2709, 2707, 1, 0, 0, 0, 2709, 2710, 1, 0, 0, 0, 2710, 159, 1, 0, 0, + 0, 2711, 2709, 1, 0, 0, 0, 2712, 2713, 5, 38, 0, 0, 2713, 2714, 5, 250, + 0, 0, 2714, 2715, 5, 880, 0, 0, 2715, 2722, 3, 856, 428, 0, 2716, 2723, + 3, 142, 71, 0, 2717, 2723, 5, 671, 0, 0, 2718, 2719, 5, 783, 0, 0, 2719, + 2720, 5, 1011, 0, 0, 2720, 2721, 5, 1092, 0, 0, 2721, 2723, 3, 856, 428, + 0, 2722, 2716, 1, 0, 0, 0, 2722, 2717, 1, 0, 0, 0, 2722, 2718, 1, 0, 0, + 0, 2723, 161, 1, 0, 0, 0, 2724, 2725, 5, 38, 0, 0, 2725, 2726, 5, 291, + 0, 0, 2726, 2728, 5, 880, 0, 0, 2727, 2729, 3, 650, 325, 0, 2728, 2727, + 1, 0, 0, 0, 2728, 2729, 1, 0, 0, 0, 2729, 2730, 1, 0, 0, 0, 2730, 2731, + 3, 878, 439, 0, 2731, 2733, 5, 671, 0, 0, 2732, 2734, 3, 852, 426, 0, 2733, + 2732, 1, 0, 0, 0, 2733, 2734, 1, 0, 0, 0, 2734, 2826, 1, 0, 0, 0, 2735, + 2736, 5, 38, 0, 0, 2736, 2737, 5, 291, 0, 0, 2737, 2739, 5, 880, 0, 0, + 2738, 2740, 3, 650, 325, 0, 2739, 2738, 1, 0, 0, 0, 2739, 2740, 1, 0, 0, + 0, 2740, 2741, 1, 0, 0, 0, 2741, 2742, 3, 878, 439, 0, 2742, 2743, 5, 14, + 0, 0, 2743, 2744, 5, 315, 0, 0, 2744, 2745, 5, 1104, 0, 0, 2745, 2746, + 3, 854, 427, 0, 2746, 2747, 5, 1105, 0, 0, 2747, 2826, 1, 0, 0, 0, 2748, + 2749, 5, 38, 0, 0, 2749, 2750, 5, 291, 0, 0, 2750, 2752, 5, 880, 0, 0, + 2751, 2753, 3, 650, 325, 0, 2752, 2751, 1, 0, 0, 0, 2752, 2753, 1, 0, 0, + 0, 2753, 2754, 1, 0, 0, 0, 2754, 2755, 3, 878, 439, 0, 2755, 2756, 5, 681, + 0, 0, 2756, 2757, 5, 315, 0, 0, 2757, 2758, 5, 1104, 0, 0, 2758, 2759, + 3, 854, 427, 0, 2759, 2760, 5, 1105, 0, 0, 2760, 2826, 1, 0, 0, 0, 2761, + 2762, 5, 38, 0, 0, 2762, 2763, 5, 291, 0, 0, 2763, 2765, 5, 880, 0, 0, + 2764, 2766, 3, 650, 325, 0, 2765, 2764, 1, 0, 0, 0, 2765, 2766, 1, 0, 0, + 0, 2766, 2767, 1, 0, 0, 0, 2767, 2768, 3, 878, 439, 0, 2768, 2772, 5, 783, + 0, 0, 2769, 2770, 5, 70, 0, 0, 2770, 2771, 5, 1092, 0, 0, 2771, 2773, 3, + 450, 225, 0, 2772, 2769, 1, 0, 0, 0, 2772, 2773, 1, 0, 0, 0, 2773, 2775, + 1, 0, 0, 0, 2774, 2776, 3, 302, 151, 0, 2775, 2774, 1, 0, 0, 0, 2775, 2776, + 1, 0, 0, 0, 2776, 2826, 1, 0, 0, 0, 2777, 2778, 5, 38, 0, 0, 2778, 2779, + 5, 291, 0, 0, 2779, 2781, 5, 880, 0, 0, 2780, 2782, 3, 650, 325, 0, 2781, + 2780, 1, 0, 0, 0, 2781, 2782, 1, 0, 0, 0, 2782, 2783, 1, 0, 0, 0, 2783, + 2784, 3, 878, 439, 0, 2784, 2785, 3, 304, 152, 0, 2785, 2826, 1, 0, 0, + 0, 2786, 2787, 5, 38, 0, 0, 2787, 2788, 5, 291, 0, 0, 2788, 2789, 5, 880, + 0, 0, 2789, 2791, 3, 878, 439, 0, 2790, 2792, 3, 650, 325, 0, 2791, 2790, + 1, 0, 0, 0, 2791, 2792, 1, 0, 0, 0, 2792, 2793, 1, 0, 0, 0, 2793, 2794, + 5, 14, 0, 0, 2794, 2795, 5, 584, 0, 0, 2795, 2796, 5, 1104, 0, 0, 2796, + 2797, 3, 874, 437, 0, 2797, 2798, 5, 1092, 0, 0, 2798, 2806, 3, 852, 426, + 0, 2799, 2800, 5, 1110, 0, 0, 2800, 2801, 3, 874, 437, 0, 2801, 2802, 5, + 1092, 0, 0, 2802, 2803, 3, 852, 426, 0, 2803, 2805, 1, 0, 0, 0, 2804, 2799, + 1, 0, 0, 0, 2805, 2808, 1, 0, 0, 0, 2806, 2804, 1, 0, 0, 0, 2806, 2807, + 1, 0, 0, 0, 2807, 2809, 1, 0, 0, 0, 2808, 2806, 1, 0, 0, 0, 2809, 2810, + 5, 1105, 0, 0, 2810, 2811, 5, 440, 0, 0, 2811, 2812, 3, 852, 426, 0, 2812, + 2826, 1, 0, 0, 0, 2813, 2814, 5, 38, 0, 0, 2814, 2815, 5, 291, 0, 0, 2815, + 2816, 5, 880, 0, 0, 2816, 2818, 3, 878, 439, 0, 2817, 2819, 3, 650, 325, + 0, 2818, 2817, 1, 0, 0, 0, 2818, 2819, 1, 0, 0, 0, 2819, 2820, 1, 0, 0, + 0, 2820, 2821, 5, 249, 0, 0, 2821, 2822, 5, 584, 0, 0, 2822, 2823, 5, 440, + 0, 0, 2823, 2824, 3, 852, 426, 0, 2824, 2826, 1, 0, 0, 0, 2825, 2724, 1, + 0, 0, 0, 2825, 2735, 1, 0, 0, 0, 2825, 2748, 1, 0, 0, 0, 2825, 2761, 1, + 0, 0, 0, 2825, 2777, 1, 0, 0, 0, 2825, 2786, 1, 0, 0, 0, 2825, 2813, 1, + 0, 0, 0, 2826, 163, 1, 0, 0, 0, 2827, 2828, 5, 367, 0, 0, 2828, 2829, 5, + 252, 0, 0, 2829, 2830, 5, 131, 0, 0, 2830, 165, 1, 0, 0, 0, 2831, 2832, + 5, 688, 0, 0, 2832, 2833, 5, 1092, 0, 0, 2833, 2834, 3, 852, 426, 0, 2834, + 167, 1, 0, 0, 0, 2835, 2840, 3, 856, 428, 0, 2836, 2837, 5, 1110, 0, 0, + 2837, 2839, 3, 856, 428, 0, 2838, 2836, 1, 0, 0, 0, 2839, 2842, 1, 0, 0, + 0, 2840, 2838, 1, 0, 0, 0, 2840, 2841, 1, 0, 0, 0, 2841, 169, 1, 0, 0, + 0, 2842, 2840, 1, 0, 0, 0, 2843, 2848, 3, 856, 428, 0, 2844, 2845, 5, 1110, + 0, 0, 2845, 2847, 3, 856, 428, 0, 2846, 2844, 1, 0, 0, 0, 2847, 2850, 1, + 0, 0, 0, 2848, 2846, 1, 0, 0, 0, 2848, 2849, 1, 0, 0, 0, 2849, 171, 1, + 0, 0, 0, 2850, 2848, 1, 0, 0, 0, 2851, 2856, 3, 344, 172, 0, 2852, 2853, + 5, 1110, 0, 0, 2853, 2855, 3, 344, 172, 0, 2854, 2852, 1, 0, 0, 0, 2855, + 2858, 1, 0, 0, 0, 2856, 2854, 1, 0, 0, 0, 2856, 2857, 1, 0, 0, 0, 2857, + 173, 1, 0, 0, 0, 2858, 2856, 1, 0, 0, 0, 2859, 2860, 5, 38, 0, 0, 2860, + 2861, 5, 307, 0, 0, 2861, 2863, 5, 350, 0, 0, 2862, 2864, 3, 650, 325, + 0, 2863, 2862, 1, 0, 0, 0, 2863, 2864, 1, 0, 0, 0, 2864, 2865, 1, 0, 0, + 0, 2865, 2866, 3, 856, 428, 0, 2866, 2867, 5, 682, 0, 0, 2867, 2868, 5, + 922, 0, 0, 2868, 2869, 3, 856, 428, 0, 2869, 3014, 1, 0, 0, 0, 2870, 2871, + 5, 38, 0, 0, 2871, 2872, 5, 307, 0, 0, 2872, 2874, 5, 350, 0, 0, 2873, + 2875, 3, 650, 325, 0, 2874, 2873, 1, 0, 0, 0, 2874, 2875, 1, 0, 0, 0, 2875, + 2876, 1, 0, 0, 0, 2876, 2877, 3, 856, 428, 0, 2877, 2881, 5, 783, 0, 0, + 2878, 2879, 5, 541, 0, 0, 2879, 2880, 5, 1092, 0, 0, 2880, 2882, 3, 838, + 419, 0, 2881, 2878, 1, 0, 0, 0, 2881, 2882, 1, 0, 0, 0, 2882, 2884, 1, + 0, 0, 0, 2883, 2885, 3, 166, 83, 0, 2884, 2883, 1, 0, 0, 0, 2884, 2885, + 1, 0, 0, 0, 2885, 3014, 1, 0, 0, 0, 2886, 2887, 5, 38, 0, 0, 2887, 2888, + 5, 307, 0, 0, 2888, 2890, 5, 350, 0, 0, 2889, 2891, 3, 650, 325, 0, 2890, + 2889, 1, 0, 0, 0, 2890, 2891, 1, 0, 0, 0, 2891, 2892, 1, 0, 0, 0, 2892, + 2893, 3, 856, 428, 0, 2893, 2894, 5, 783, 0, 0, 2894, 2895, 5, 541, 0, + 0, 2895, 2896, 5, 1092, 0, 0, 2896, 2898, 3, 838, 419, 0, 2897, 2899, 3, + 166, 83, 0, 2898, 2897, 1, 0, 0, 0, 2898, 2899, 1, 0, 0, 0, 2899, 3014, + 1, 0, 0, 0, 2900, 2901, 5, 38, 0, 0, 2901, 2902, 5, 307, 0, 0, 2902, 2904, + 5, 350, 0, 0, 2903, 2905, 3, 650, 325, 0, 2904, 2903, 1, 0, 0, 0, 2904, + 2905, 1, 0, 0, 0, 2905, 2906, 1, 0, 0, 0, 2906, 2907, 3, 856, 428, 0, 2907, + 2908, 5, 14, 0, 0, 2908, 2909, 3, 168, 84, 0, 2909, 2910, 5, 922, 0, 0, + 2910, 2911, 5, 26, 0, 0, 2911, 3014, 1, 0, 0, 0, 2912, 2913, 5, 38, 0, + 0, 2913, 2914, 5, 307, 0, 0, 2914, 2916, 5, 350, 0, 0, 2915, 2917, 3, 650, + 325, 0, 2916, 2915, 1, 0, 0, 0, 2916, 2917, 1, 0, 0, 0, 2917, 2918, 1, + 0, 0, 0, 2918, 2919, 3, 856, 428, 0, 2919, 2920, 5, 487, 0, 0, 2920, 2921, + 5, 208, 0, 0, 2921, 2922, 3, 168, 84, 0, 2922, 2923, 5, 922, 0, 0, 2923, + 2924, 5, 307, 0, 0, 2924, 2925, 5, 350, 0, 0, 2925, 2926, 3, 856, 428, + 0, 2926, 3014, 1, 0, 0, 0, 2927, 2928, 5, 38, 0, 0, 2928, 2929, 5, 307, + 0, 0, 2929, 2931, 5, 350, 0, 0, 2930, 2932, 3, 650, 325, 0, 2931, 2930, + 1, 0, 0, 0, 2931, 2932, 1, 0, 0, 0, 2932, 2933, 1, 0, 0, 0, 2933, 2934, + 3, 856, 428, 0, 2934, 2935, 5, 681, 0, 0, 2935, 2936, 3, 168, 84, 0, 2936, + 2937, 5, 329, 0, 0, 2937, 2938, 5, 26, 0, 0, 2938, 3014, 1, 0, 0, 0, 2939, + 2940, 5, 38, 0, 0, 2940, 2941, 5, 307, 0, 0, 2941, 2943, 5, 350, 0, 0, + 2942, 2944, 3, 650, 325, 0, 2943, 2942, 1, 0, 0, 0, 2943, 2944, 1, 0, 0, + 0, 2944, 2945, 1, 0, 0, 0, 2945, 2946, 3, 856, 428, 0, 2946, 2947, 5, 14, + 0, 0, 2947, 2948, 3, 170, 85, 0, 2948, 2949, 5, 922, 0, 0, 2949, 2950, + 5, 29, 0, 0, 2950, 3014, 1, 0, 0, 0, 2951, 2952, 5, 38, 0, 0, 2952, 2953, + 5, 307, 0, 0, 2953, 2955, 5, 350, 0, 0, 2954, 2956, 3, 650, 325, 0, 2955, + 2954, 1, 0, 0, 0, 2955, 2956, 1, 0, 0, 0, 2956, 2957, 1, 0, 0, 0, 2957, + 2958, 3, 856, 428, 0, 2958, 2959, 5, 487, 0, 0, 2959, 2960, 5, 788, 0, + 0, 2960, 2961, 3, 170, 85, 0, 2961, 2962, 5, 922, 0, 0, 2962, 2963, 5, + 307, 0, 0, 2963, 2964, 5, 350, 0, 0, 2964, 2965, 3, 856, 428, 0, 2965, + 3014, 1, 0, 0, 0, 2966, 2967, 5, 38, 0, 0, 2967, 2968, 5, 307, 0, 0, 2968, + 2970, 5, 350, 0, 0, 2969, 2971, 3, 650, 325, 0, 2970, 2969, 1, 0, 0, 0, + 2970, 2971, 1, 0, 0, 0, 2971, 2972, 1, 0, 0, 0, 2972, 2973, 3, 856, 428, + 0, 2973, 2974, 5, 681, 0, 0, 2974, 2975, 3, 170, 85, 0, 2975, 2976, 5, + 329, 0, 0, 2976, 2977, 5, 29, 0, 0, 2977, 3014, 1, 0, 0, 0, 2978, 2979, + 5, 38, 0, 0, 2979, 2980, 5, 307, 0, 0, 2980, 2982, 5, 350, 0, 0, 2981, + 2983, 3, 650, 325, 0, 2982, 2981, 1, 0, 0, 0, 2982, 2983, 1, 0, 0, 0, 2983, + 2984, 1, 0, 0, 0, 2984, 2985, 3, 856, 428, 0, 2985, 2986, 5, 14, 0, 0, + 2986, 2987, 3, 172, 86, 0, 2987, 2988, 5, 922, 0, 0, 2988, 2990, 5, 25, + 0, 0, 2989, 2991, 3, 164, 82, 0, 2990, 2989, 1, 0, 0, 0, 2990, 2991, 1, + 0, 0, 0, 2991, 3014, 1, 0, 0, 0, 2992, 2993, 5, 38, 0, 0, 2993, 2994, 5, + 307, 0, 0, 2994, 2996, 5, 350, 0, 0, 2995, 2997, 3, 650, 325, 0, 2996, + 2995, 1, 0, 0, 0, 2996, 2997, 1, 0, 0, 0, 2997, 2998, 1, 0, 0, 0, 2998, + 2999, 3, 856, 428, 0, 2999, 3000, 5, 681, 0, 0, 3000, 3001, 3, 172, 86, + 0, 3001, 3002, 5, 329, 0, 0, 3002, 3003, 5, 25, 0, 0, 3003, 3014, 1, 0, + 0, 0, 3004, 3005, 5, 38, 0, 0, 3005, 3006, 5, 307, 0, 0, 3006, 3008, 5, + 350, 0, 0, 3007, 3009, 3, 650, 325, 0, 3008, 3007, 1, 0, 0, 0, 3008, 3009, + 1, 0, 0, 0, 3009, 3010, 1, 0, 0, 0, 3010, 3011, 3, 856, 428, 0, 3011, 3012, + 7, 14, 0, 0, 3012, 3014, 1, 0, 0, 0, 3013, 2859, 1, 0, 0, 0, 3013, 2870, + 1, 0, 0, 0, 3013, 2886, 1, 0, 0, 0, 3013, 2900, 1, 0, 0, 0, 3013, 2912, + 1, 0, 0, 0, 3013, 2927, 1, 0, 0, 0, 3013, 2939, 1, 0, 0, 0, 3013, 2951, + 1, 0, 0, 0, 3013, 2966, 1, 0, 0, 0, 3013, 2978, 1, 0, 0, 0, 3013, 2992, + 1, 0, 0, 0, 3013, 3004, 1, 0, 0, 0, 3014, 175, 1, 0, 0, 0, 3015, 3016, + 5, 38, 0, 0, 3016, 3017, 5, 314, 0, 0, 3017, 3019, 5, 325, 0, 0, 3018, + 3020, 3, 650, 325, 0, 3019, 3018, 1, 0, 0, 0, 3019, 3020, 1, 0, 0, 0, 3020, + 3021, 1, 0, 0, 0, 3021, 3022, 3, 856, 428, 0, 3022, 3023, 5, 682, 0, 0, + 3023, 3024, 5, 922, 0, 0, 3024, 3025, 3, 856, 428, 0, 3025, 3044, 1, 0, + 0, 0, 3026, 3027, 5, 38, 0, 0, 3027, 3028, 5, 314, 0, 0, 3028, 3030, 5, + 325, 0, 0, 3029, 3031, 3, 650, 325, 0, 3030, 3029, 1, 0, 0, 0, 3030, 3031, + 1, 0, 0, 0, 3031, 3032, 1, 0, 0, 0, 3032, 3033, 3, 856, 428, 0, 3033, 3037, + 5, 783, 0, 0, 3034, 3036, 3, 426, 213, 0, 3035, 3034, 1, 0, 0, 0, 3036, + 3039, 1, 0, 0, 0, 3037, 3035, 1, 0, 0, 0, 3037, 3038, 1, 0, 0, 0, 3038, + 3041, 1, 0, 0, 0, 3039, 3037, 1, 0, 0, 0, 3040, 3042, 3, 646, 323, 0, 3041, + 3040, 1, 0, 0, 0, 3041, 3042, 1, 0, 0, 0, 3042, 3044, 1, 0, 0, 0, 3043, + 3015, 1, 0, 0, 0, 3043, 3026, 1, 0, 0, 0, 3044, 177, 1, 0, 0, 0, 3045, + 3046, 3, 180, 90, 0, 3046, 3047, 5, 682, 0, 0, 3047, 3048, 5, 922, 0, 0, + 3048, 3049, 3, 856, 428, 0, 3049, 3117, 1, 0, 0, 0, 3050, 3051, 3, 180, + 90, 0, 3051, 3052, 5, 783, 0, 0, 3052, 3053, 3, 646, 323, 0, 3053, 3117, + 1, 0, 0, 0, 3054, 3055, 3, 180, 90, 0, 3055, 3056, 5, 783, 0, 0, 3056, + 3057, 5, 769, 0, 0, 3057, 3117, 1, 0, 0, 0, 3058, 3059, 3, 180, 90, 0, + 3059, 3060, 5, 974, 0, 0, 3060, 3061, 7, 15, 0, 0, 3061, 3117, 1, 0, 0, + 0, 3062, 3063, 3, 180, 90, 0, 3063, 3064, 5, 783, 0, 0, 3064, 3065, 5, + 48, 0, 0, 3065, 3066, 5, 1092, 0, 0, 3066, 3067, 3, 856, 428, 0, 3067, + 3117, 1, 0, 0, 0, 3068, 3069, 3, 180, 90, 0, 3069, 3070, 5, 783, 0, 0, + 3070, 3071, 5, 357, 0, 0, 3071, 3072, 5, 1092, 0, 0, 3072, 3076, 5, 1104, + 0, 0, 3073, 3075, 3, 330, 165, 0, 3074, 3073, 1, 0, 0, 0, 3075, 3078, 1, + 0, 0, 0, 3076, 3074, 1, 0, 0, 0, 3076, 3077, 1, 0, 0, 0, 3077, 3079, 1, + 0, 0, 0, 3078, 3076, 1, 0, 0, 0, 3079, 3080, 5, 1105, 0, 0, 3080, 3117, + 1, 0, 0, 0, 3081, 3082, 3, 180, 90, 0, 3082, 3083, 5, 783, 0, 0, 3083, + 3084, 5, 179, 0, 0, 3084, 3085, 5, 1092, 0, 0, 3085, 3089, 5, 1104, 0, + 0, 3086, 3088, 3, 856, 428, 0, 3087, 3086, 1, 0, 0, 0, 3088, 3091, 1, 0, + 0, 0, 3089, 3087, 1, 0, 0, 0, 3089, 3090, 1, 0, 0, 0, 3090, 3092, 1, 0, + 0, 0, 3091, 3089, 1, 0, 0, 0, 3092, 3093, 5, 1105, 0, 0, 3093, 3117, 1, + 0, 0, 0, 3094, 3095, 3, 180, 90, 0, 3095, 3096, 5, 783, 0, 0, 3096, 3097, + 5, 464, 0, 0, 3097, 3098, 5, 1092, 0, 0, 3098, 3099, 3, 880, 440, 0, 3099, + 3117, 1, 0, 0, 0, 3100, 3101, 3, 180, 90, 0, 3101, 3102, 5, 783, 0, 0, + 3102, 3103, 5, 165, 0, 0, 3103, 3104, 5, 1092, 0, 0, 3104, 3105, 3, 332, + 166, 0, 3105, 3117, 1, 0, 0, 0, 3106, 3107, 3, 180, 90, 0, 3107, 3108, + 5, 783, 0, 0, 3108, 3109, 7, 16, 0, 0, 3109, 3110, 5, 1092, 0, 0, 3110, + 3111, 3, 856, 428, 0, 3111, 3117, 1, 0, 0, 0, 3112, 3113, 3, 180, 90, 0, + 3113, 3114, 5, 974, 0, 0, 3114, 3115, 7, 17, 0, 0, 3115, 3117, 1, 0, 0, + 0, 3116, 3045, 1, 0, 0, 0, 3116, 3050, 1, 0, 0, 0, 3116, 3054, 1, 0, 0, + 0, 3116, 3058, 1, 0, 0, 0, 3116, 3062, 1, 0, 0, 0, 3116, 3068, 1, 0, 0, + 0, 3116, 3081, 1, 0, 0, 0, 3116, 3094, 1, 0, 0, 0, 3116, 3100, 1, 0, 0, + 0, 3116, 3106, 1, 0, 0, 0, 3116, 3112, 1, 0, 0, 0, 3117, 179, 1, 0, 0, + 0, 3118, 3119, 5, 38, 0, 0, 3119, 3121, 5, 331, 0, 0, 3120, 3122, 3, 650, + 325, 0, 3121, 3120, 1, 0, 0, 0, 3121, 3122, 1, 0, 0, 0, 3122, 3123, 1, + 0, 0, 0, 3123, 3124, 3, 856, 428, 0, 3124, 3126, 5, 1104, 0, 0, 3125, 3127, + 3, 182, 91, 0, 3126, 3125, 1, 0, 0, 0, 3126, 3127, 1, 0, 0, 0, 3127, 3128, + 1, 0, 0, 0, 3128, 3129, 5, 1105, 0, 0, 3129, 181, 1, 0, 0, 0, 3130, 3135, + 3, 902, 451, 0, 3131, 3132, 5, 1110, 0, 0, 3132, 3134, 3, 902, 451, 0, + 3133, 3131, 1, 0, 0, 0, 3134, 3137, 1, 0, 0, 0, 3135, 3133, 1, 0, 0, 0, + 3135, 3136, 1, 0, 0, 0, 3136, 183, 1, 0, 0, 0, 3137, 3135, 1, 0, 0, 0, + 3138, 3139, 5, 38, 0, 0, 3139, 3140, 5, 455, 0, 0, 3140, 3142, 5, 608, + 0, 0, 3141, 3143, 3, 650, 325, 0, 3142, 3141, 1, 0, 0, 0, 3142, 3143, 1, + 0, 0, 0, 3143, 3144, 1, 0, 0, 0, 3144, 3145, 3, 856, 428, 0, 3145, 3146, + 5, 783, 0, 0, 3146, 3147, 5, 106, 0, 0, 3147, 3148, 5, 1088, 0, 0, 3148, + 3149, 3, 886, 443, 0, 3149, 3172, 1, 0, 0, 0, 3150, 3151, 5, 38, 0, 0, + 3151, 3152, 5, 455, 0, 0, 3152, 3154, 5, 608, 0, 0, 3153, 3155, 3, 650, + 325, 0, 3154, 3153, 1, 0, 0, 0, 3154, 3155, 1, 0, 0, 0, 3155, 3156, 1, + 0, 0, 0, 3156, 3157, 3, 856, 428, 0, 3157, 3158, 5, 682, 0, 0, 3158, 3159, + 5, 922, 0, 0, 3159, 3160, 3, 856, 428, 0, 3160, 3172, 1, 0, 0, 0, 3161, + 3162, 5, 38, 0, 0, 3162, 3163, 5, 455, 0, 0, 3163, 3165, 5, 608, 0, 0, + 3164, 3166, 3, 650, 325, 0, 3165, 3164, 1, 0, 0, 0, 3165, 3166, 1, 0, 0, + 0, 3166, 3167, 1, 0, 0, 0, 3167, 3168, 3, 856, 428, 0, 3168, 3169, 5, 783, + 0, 0, 3169, 3170, 3, 646, 323, 0, 3170, 3172, 1, 0, 0, 0, 3171, 3138, 1, + 0, 0, 0, 3171, 3150, 1, 0, 0, 0, 3171, 3161, 1, 0, 0, 0, 3172, 185, 1, + 0, 0, 0, 3173, 3174, 5, 38, 0, 0, 3174, 3175, 5, 463, 0, 0, 3175, 3176, + 5, 1005, 0, 0, 3176, 3202, 3, 856, 428, 0, 3177, 3178, 5, 682, 0, 0, 3178, + 3179, 5, 922, 0, 0, 3179, 3203, 3, 856, 428, 0, 3180, 3181, 5, 151, 0, + 0, 3181, 3182, 5, 110, 0, 0, 3182, 3183, 5, 1104, 0, 0, 3183, 3184, 3, + 882, 441, 0, 3184, 3185, 5, 1105, 0, 0, 3185, 3203, 1, 0, 0, 0, 3186, 3187, + 5, 249, 0, 0, 3187, 3188, 5, 153, 0, 0, 3188, 3203, 5, 413, 0, 0, 3189, + 3191, 3, 142, 71, 0, 3190, 3192, 5, 662, 0, 0, 3191, 3190, 1, 0, 0, 0, + 3191, 3192, 1, 0, 0, 0, 3192, 3203, 1, 0, 0, 0, 3193, 3195, 5, 783, 0, + 0, 3194, 3196, 5, 769, 0, 0, 3195, 3194, 1, 0, 0, 0, 3195, 3196, 1, 0, + 0, 0, 3196, 3198, 1, 0, 0, 0, 3197, 3199, 3, 646, 323, 0, 3198, 3197, 1, + 0, 0, 0, 3198, 3199, 1, 0, 0, 0, 3199, 3203, 1, 0, 0, 0, 3200, 3201, 5, + 974, 0, 0, 3201, 3203, 7, 15, 0, 0, 3202, 3177, 1, 0, 0, 0, 3202, 3180, + 1, 0, 0, 0, 3202, 3186, 1, 0, 0, 0, 3202, 3189, 1, 0, 0, 0, 3202, 3193, + 1, 0, 0, 0, 3202, 3200, 1, 0, 0, 0, 3203, 187, 1, 0, 0, 0, 3204, 3205, + 5, 38, 0, 0, 3205, 3206, 5, 496, 0, 0, 3206, 3207, 5, 608, 0, 0, 3207, + 3208, 3, 294, 147, 0, 3208, 189, 1, 0, 0, 0, 3209, 3211, 5, 38, 0, 0, 3210, + 3212, 5, 512, 0, 0, 3211, 3210, 1, 0, 0, 0, 3211, 3212, 1, 0, 0, 0, 3212, + 3213, 1, 0, 0, 0, 3213, 3215, 5, 394, 0, 0, 3214, 3216, 3, 650, 325, 0, + 3215, 3214, 1, 0, 0, 0, 3215, 3216, 1, 0, 0, 0, 3216, 3217, 1, 0, 0, 0, + 3217, 3218, 3, 856, 428, 0, 3218, 3220, 5, 783, 0, 0, 3219, 3221, 3, 138, + 69, 0, 3220, 3219, 1, 0, 0, 0, 3220, 3221, 1, 0, 0, 0, 3221, 3222, 1, 0, + 0, 0, 3222, 3224, 3, 374, 187, 0, 3223, 3225, 3, 646, 323, 0, 3224, 3223, + 1, 0, 0, 0, 3224, 3225, 1, 0, 0, 0, 3225, 3270, 1, 0, 0, 0, 3226, 3228, + 5, 38, 0, 0, 3227, 3229, 5, 512, 0, 0, 3228, 3227, 1, 0, 0, 0, 3228, 3229, + 1, 0, 0, 0, 3229, 3230, 1, 0, 0, 0, 3230, 3232, 5, 394, 0, 0, 3231, 3233, + 3, 650, 325, 0, 3232, 3231, 1, 0, 0, 0, 3232, 3233, 1, 0, 0, 0, 3233, 3234, + 1, 0, 0, 0, 3234, 3235, 3, 856, 428, 0, 3235, 3237, 5, 783, 0, 0, 3236, + 3238, 3, 138, 69, 0, 3237, 3236, 1, 0, 0, 0, 3237, 3238, 1, 0, 0, 0, 3238, + 3239, 1, 0, 0, 0, 3239, 3241, 3, 376, 188, 0, 3240, 3242, 3, 646, 323, + 0, 3241, 3240, 1, 0, 0, 0, 3241, 3242, 1, 0, 0, 0, 3242, 3270, 1, 0, 0, + 0, 3243, 3245, 5, 38, 0, 0, 3244, 3246, 5, 512, 0, 0, 3245, 3244, 1, 0, + 0, 0, 3245, 3246, 1, 0, 0, 0, 3246, 3247, 1, 0, 0, 0, 3247, 3248, 5, 394, + 0, 0, 3248, 3249, 3, 856, 428, 0, 3249, 3250, 3, 300, 150, 0, 3250, 3270, + 1, 0, 0, 0, 3251, 3253, 5, 38, 0, 0, 3252, 3254, 5, 512, 0, 0, 3253, 3252, + 1, 0, 0, 0, 3253, 3254, 1, 0, 0, 0, 3254, 3255, 1, 0, 0, 0, 3255, 3256, + 5, 394, 0, 0, 3256, 3257, 3, 856, 428, 0, 3257, 3258, 3, 304, 152, 0, 3258, + 3270, 1, 0, 0, 0, 3259, 3261, 5, 38, 0, 0, 3260, 3262, 5, 512, 0, 0, 3261, + 3260, 1, 0, 0, 0, 3261, 3262, 1, 0, 0, 0, 3262, 3263, 1, 0, 0, 0, 3263, + 3264, 5, 394, 0, 0, 3264, 3265, 3, 650, 325, 0, 3265, 3266, 3, 856, 428, + 0, 3266, 3267, 5, 974, 0, 0, 3267, 3268, 7, 18, 0, 0, 3268, 3270, 1, 0, + 0, 0, 3269, 3209, 1, 0, 0, 0, 3269, 3226, 1, 0, 0, 0, 3269, 3243, 1, 0, + 0, 0, 3269, 3251, 1, 0, 0, 0, 3269, 3259, 1, 0, 0, 0, 3270, 191, 1, 0, + 0, 0, 3271, 3272, 5, 38, 0, 0, 3272, 3274, 5, 601, 0, 0, 3273, 3275, 3, + 650, 325, 0, 3274, 3273, 1, 0, 0, 0, 3274, 3275, 1, 0, 0, 0, 3275, 3276, + 1, 0, 0, 0, 3276, 3277, 3, 856, 428, 0, 3277, 3279, 5, 783, 0, 0, 3278, + 3280, 3, 132, 66, 0, 3279, 3278, 1, 0, 0, 0, 3279, 3280, 1, 0, 0, 0, 3280, + 3282, 1, 0, 0, 0, 3281, 3283, 3, 646, 323, 0, 3282, 3281, 1, 0, 0, 0, 3282, + 3283, 1, 0, 0, 0, 3283, 3332, 1, 0, 0, 0, 3284, 3285, 5, 38, 0, 0, 3285, + 3286, 5, 601, 0, 0, 3286, 3287, 3, 856, 428, 0, 3287, 3288, 3, 300, 150, + 0, 3288, 3332, 1, 0, 0, 0, 3289, 3290, 5, 38, 0, 0, 3290, 3291, 5, 601, + 0, 0, 3291, 3292, 3, 856, 428, 0, 3292, 3293, 3, 304, 152, 0, 3293, 3332, + 1, 0, 0, 0, 3294, 3295, 5, 38, 0, 0, 3295, 3297, 5, 601, 0, 0, 3296, 3298, + 3, 650, 325, 0, 3297, 3296, 1, 0, 0, 0, 3297, 3298, 1, 0, 0, 0, 3298, 3299, + 1, 0, 0, 0, 3299, 3300, 3, 856, 428, 0, 3300, 3301, 5, 974, 0, 0, 3301, + 3302, 5, 603, 0, 0, 3302, 3303, 5, 1092, 0, 0, 3303, 3304, 3, 450, 225, + 0, 3304, 3332, 1, 0, 0, 0, 3305, 3306, 5, 38, 0, 0, 3306, 3308, 5, 601, + 0, 0, 3307, 3309, 3, 650, 325, 0, 3308, 3307, 1, 0, 0, 0, 3308, 3309, 1, + 0, 0, 0, 3309, 3310, 1, 0, 0, 0, 3310, 3311, 3, 856, 428, 0, 3311, 3312, + 5, 974, 0, 0, 3312, 3313, 5, 161, 0, 0, 3313, 3332, 1, 0, 0, 0, 3314, 3315, + 5, 38, 0, 0, 3315, 3317, 5, 601, 0, 0, 3316, 3318, 3, 650, 325, 0, 3317, + 3316, 1, 0, 0, 0, 3317, 3318, 1, 0, 0, 0, 3318, 3319, 1, 0, 0, 0, 3319, + 3320, 3, 856, 428, 0, 3320, 3324, 5, 671, 0, 0, 3321, 3322, 5, 614, 0, + 0, 3322, 3323, 5, 1092, 0, 0, 3323, 3325, 3, 852, 426, 0, 3324, 3321, 1, + 0, 0, 0, 3324, 3325, 1, 0, 0, 0, 3325, 3329, 1, 0, 0, 0, 3326, 3327, 5, + 482, 0, 0, 3327, 3328, 5, 1092, 0, 0, 3328, 3330, 3, 852, 426, 0, 3329, + 3326, 1, 0, 0, 0, 3329, 3330, 1, 0, 0, 0, 3330, 3332, 1, 0, 0, 0, 3331, + 3271, 1, 0, 0, 0, 3331, 3284, 1, 0, 0, 0, 3331, 3289, 1, 0, 0, 0, 3331, + 3294, 1, 0, 0, 0, 3331, 3305, 1, 0, 0, 0, 3331, 3314, 1, 0, 0, 0, 3332, + 193, 1, 0, 0, 0, 3333, 3334, 5, 38, 0, 0, 3334, 3336, 5, 628, 0, 0, 3335, + 3337, 3, 650, 325, 0, 3336, 3335, 1, 0, 0, 0, 3336, 3337, 1, 0, 0, 0, 3337, + 3338, 1, 0, 0, 0, 3338, 3339, 3, 856, 428, 0, 3339, 3341, 5, 1104, 0, 0, + 3340, 3342, 3, 182, 91, 0, 3341, 3340, 1, 0, 0, 0, 3341, 3342, 1, 0, 0, + 0, 3342, 3343, 1, 0, 0, 0, 3343, 3344, 5, 1105, 0, 0, 3344, 3345, 5, 682, + 0, 0, 3345, 3346, 5, 922, 0, 0, 3346, 3347, 3, 856, 428, 0, 3347, 3392, + 1, 0, 0, 0, 3348, 3349, 5, 38, 0, 0, 3349, 3351, 5, 628, 0, 0, 3350, 3352, + 3, 650, 325, 0, 3351, 3350, 1, 0, 0, 0, 3351, 3352, 1, 0, 0, 0, 3352, 3353, + 1, 0, 0, 0, 3353, 3354, 3, 856, 428, 0, 3354, 3356, 5, 1104, 0, 0, 3355, + 3357, 3, 182, 91, 0, 3356, 3355, 1, 0, 0, 0, 3356, 3357, 1, 0, 0, 0, 3357, + 3358, 1, 0, 0, 0, 3358, 3359, 5, 1105, 0, 0, 3359, 3360, 5, 783, 0, 0, + 3360, 3361, 3, 646, 323, 0, 3361, 3392, 1, 0, 0, 0, 3362, 3363, 5, 38, + 0, 0, 3363, 3365, 5, 628, 0, 0, 3364, 3366, 3, 650, 325, 0, 3365, 3364, + 1, 0, 0, 0, 3365, 3366, 1, 0, 0, 0, 3366, 3367, 1, 0, 0, 0, 3367, 3368, + 3, 856, 428, 0, 3368, 3370, 5, 1104, 0, 0, 3369, 3371, 3, 182, 91, 0, 3370, + 3369, 1, 0, 0, 0, 3370, 3371, 1, 0, 0, 0, 3371, 3372, 1, 0, 0, 0, 3372, + 3373, 5, 1105, 0, 0, 3373, 3374, 5, 974, 0, 0, 3374, 3375, 5, 161, 0, 0, + 3375, 3392, 1, 0, 0, 0, 3376, 3377, 5, 38, 0, 0, 3377, 3379, 5, 628, 0, + 0, 3378, 3380, 3, 650, 325, 0, 3379, 3378, 1, 0, 0, 0, 3379, 3380, 1, 0, + 0, 0, 3380, 3381, 1, 0, 0, 0, 3381, 3382, 3, 856, 428, 0, 3382, 3384, 5, + 1104, 0, 0, 3383, 3385, 3, 182, 91, 0, 3384, 3383, 1, 0, 0, 0, 3384, 3385, + 1, 0, 0, 0, 3385, 3386, 1, 0, 0, 0, 3386, 3387, 5, 1105, 0, 0, 3387, 3388, + 5, 282, 0, 0, 3388, 3389, 5, 56, 0, 0, 3389, 3390, 3, 382, 191, 0, 3390, + 3392, 1, 0, 0, 0, 3391, 3333, 1, 0, 0, 0, 3391, 3348, 1, 0, 0, 0, 3391, + 3362, 1, 0, 0, 0, 3391, 3376, 1, 0, 0, 0, 3392, 195, 1, 0, 0, 0, 3393, + 3394, 5, 38, 0, 0, 3394, 3395, 5, 687, 0, 0, 3395, 3397, 5, 350, 0, 0, + 3396, 3398, 3, 650, 325, 0, 3397, 3396, 1, 0, 0, 0, 3397, 3398, 1, 0, 0, + 0, 3398, 3399, 1, 0, 0, 0, 3399, 3400, 3, 856, 428, 0, 3400, 3401, 5, 682, + 0, 0, 3401, 3402, 5, 922, 0, 0, 3402, 3403, 3, 856, 428, 0, 3403, 3580, + 1, 0, 0, 0, 3404, 3405, 5, 38, 0, 0, 3405, 3406, 5, 687, 0, 0, 3406, 3408, + 5, 350, 0, 0, 3407, 3409, 3, 650, 325, 0, 3408, 3407, 1, 0, 0, 0, 3408, + 3409, 1, 0, 0, 0, 3409, 3410, 1, 0, 0, 0, 3410, 3411, 3, 856, 428, 0, 3411, + 3415, 5, 783, 0, 0, 3412, 3413, 5, 541, 0, 0, 3413, 3414, 5, 1092, 0, 0, + 3414, 3416, 3, 838, 419, 0, 3415, 3412, 1, 0, 0, 0, 3415, 3416, 1, 0, 0, + 0, 3416, 3420, 1, 0, 0, 0, 3417, 3418, 5, 688, 0, 0, 3418, 3419, 5, 1092, + 0, 0, 3419, 3421, 3, 852, 426, 0, 3420, 3417, 1, 0, 0, 0, 3420, 3421, 1, + 0, 0, 0, 3421, 3580, 1, 0, 0, 0, 3422, 3423, 5, 38, 0, 0, 3423, 3424, 5, + 687, 0, 0, 3424, 3426, 5, 350, 0, 0, 3425, 3427, 3, 650, 325, 0, 3426, + 3425, 1, 0, 0, 0, 3426, 3427, 1, 0, 0, 0, 3427, 3428, 1, 0, 0, 0, 3428, + 3429, 3, 856, 428, 0, 3429, 3430, 5, 783, 0, 0, 3430, 3431, 5, 541, 0, + 0, 3431, 3432, 5, 1092, 0, 0, 3432, 3433, 3, 838, 419, 0, 3433, 3434, 5, + 27, 0, 0, 3434, 3435, 5, 1092, 0, 0, 3435, 3440, 3, 346, 173, 0, 3436, + 3437, 5, 1110, 0, 0, 3437, 3439, 3, 346, 173, 0, 3438, 3436, 1, 0, 0, 0, + 3439, 3442, 1, 0, 0, 0, 3440, 3438, 1, 0, 0, 0, 3440, 3441, 1, 0, 0, 0, + 3441, 3446, 1, 0, 0, 0, 3442, 3440, 1, 0, 0, 0, 3443, 3444, 5, 688, 0, + 0, 3444, 3445, 5, 1092, 0, 0, 3445, 3447, 3, 852, 426, 0, 3446, 3443, 1, + 0, 0, 0, 3446, 3447, 1, 0, 0, 0, 3447, 3580, 1, 0, 0, 0, 3448, 3449, 5, + 38, 0, 0, 3449, 3450, 5, 687, 0, 0, 3450, 3452, 5, 350, 0, 0, 3451, 3453, + 3, 650, 325, 0, 3452, 3451, 1, 0, 0, 0, 3452, 3453, 1, 0, 0, 0, 3453, 3454, + 1, 0, 0, 0, 3454, 3455, 3, 856, 428, 0, 3455, 3456, 5, 14, 0, 0, 3456, + 3457, 3, 168, 84, 0, 3457, 3458, 5, 922, 0, 0, 3458, 3459, 5, 26, 0, 0, + 3459, 3580, 1, 0, 0, 0, 3460, 3461, 5, 38, 0, 0, 3461, 3462, 5, 687, 0, + 0, 3462, 3464, 5, 350, 0, 0, 3463, 3465, 3, 650, 325, 0, 3464, 3463, 1, + 0, 0, 0, 3464, 3465, 1, 0, 0, 0, 3465, 3466, 1, 0, 0, 0, 3466, 3467, 3, + 856, 428, 0, 3467, 3468, 5, 487, 0, 0, 3468, 3469, 5, 208, 0, 0, 3469, + 3470, 3, 168, 84, 0, 3470, 3471, 5, 922, 0, 0, 3471, 3472, 5, 687, 0, 0, + 3472, 3473, 5, 350, 0, 0, 3473, 3474, 3, 856, 428, 0, 3474, 3580, 1, 0, + 0, 0, 3475, 3476, 5, 38, 0, 0, 3476, 3477, 5, 687, 0, 0, 3477, 3479, 5, + 350, 0, 0, 3478, 3480, 3, 650, 325, 0, 3479, 3478, 1, 0, 0, 0, 3479, 3480, + 1, 0, 0, 0, 3480, 3481, 1, 0, 0, 0, 3481, 3482, 3, 856, 428, 0, 3482, 3483, + 5, 681, 0, 0, 3483, 3484, 3, 168, 84, 0, 3484, 3485, 5, 329, 0, 0, 3485, + 3486, 5, 26, 0, 0, 3486, 3580, 1, 0, 0, 0, 3487, 3488, 5, 38, 0, 0, 3488, + 3489, 5, 687, 0, 0, 3489, 3491, 5, 350, 0, 0, 3490, 3492, 3, 650, 325, + 0, 3491, 3490, 1, 0, 0, 0, 3491, 3492, 1, 0, 0, 0, 3492, 3493, 1, 0, 0, + 0, 3493, 3494, 3, 856, 428, 0, 3494, 3495, 5, 14, 0, 0, 3495, 3496, 3, + 170, 85, 0, 3496, 3497, 5, 922, 0, 0, 3497, 3498, 5, 29, 0, 0, 3498, 3580, + 1, 0, 0, 0, 3499, 3500, 5, 38, 0, 0, 3500, 3501, 5, 687, 0, 0, 3501, 3503, + 5, 350, 0, 0, 3502, 3504, 3, 650, 325, 0, 3503, 3502, 1, 0, 0, 0, 3503, + 3504, 1, 0, 0, 0, 3504, 3505, 1, 0, 0, 0, 3505, 3506, 3, 856, 428, 0, 3506, + 3507, 5, 487, 0, 0, 3507, 3508, 5, 788, 0, 0, 3508, 3509, 3, 170, 85, 0, + 3509, 3510, 5, 922, 0, 0, 3510, 3511, 5, 687, 0, 0, 3511, 3512, 5, 350, + 0, 0, 3512, 3513, 3, 856, 428, 0, 3513, 3580, 1, 0, 0, 0, 3514, 3515, 5, + 38, 0, 0, 3515, 3516, 5, 687, 0, 0, 3516, 3518, 5, 350, 0, 0, 3517, 3519, + 3, 650, 325, 0, 3518, 3517, 1, 0, 0, 0, 3518, 3519, 1, 0, 0, 0, 3519, 3520, + 1, 0, 0, 0, 3520, 3521, 3, 856, 428, 0, 3521, 3522, 5, 681, 0, 0, 3522, + 3523, 3, 170, 85, 0, 3523, 3524, 5, 329, 0, 0, 3524, 3525, 5, 29, 0, 0, + 3525, 3580, 1, 0, 0, 0, 3526, 3527, 5, 38, 0, 0, 3527, 3528, 5, 687, 0, + 0, 3528, 3530, 5, 350, 0, 0, 3529, 3531, 3, 650, 325, 0, 3530, 3529, 1, + 0, 0, 0, 3530, 3531, 1, 0, 0, 0, 3531, 3532, 1, 0, 0, 0, 3532, 3533, 3, + 856, 428, 0, 3533, 3534, 5, 14, 0, 0, 3534, 3535, 3, 158, 79, 0, 3535, + 3536, 5, 922, 0, 0, 3536, 3538, 5, 25, 0, 0, 3537, 3539, 3, 164, 82, 0, + 3538, 3537, 1, 0, 0, 0, 3538, 3539, 1, 0, 0, 0, 3539, 3580, 1, 0, 0, 0, + 3540, 3541, 5, 38, 0, 0, 3541, 3542, 5, 687, 0, 0, 3542, 3544, 5, 350, + 0, 0, 3543, 3545, 3, 650, 325, 0, 3544, 3543, 1, 0, 0, 0, 3544, 3545, 1, + 0, 0, 0, 3545, 3546, 1, 0, 0, 0, 3546, 3547, 3, 856, 428, 0, 3547, 3548, + 5, 681, 0, 0, 3548, 3549, 3, 158, 79, 0, 3549, 3550, 5, 329, 0, 0, 3550, + 3551, 5, 25, 0, 0, 3551, 3580, 1, 0, 0, 0, 3552, 3553, 5, 38, 0, 0, 3553, + 3554, 5, 687, 0, 0, 3554, 3556, 5, 350, 0, 0, 3555, 3557, 3, 650, 325, + 0, 3556, 3555, 1, 0, 0, 0, 3556, 3557, 1, 0, 0, 0, 3557, 3558, 1, 0, 0, + 0, 3558, 3559, 3, 856, 428, 0, 3559, 3560, 5, 671, 0, 0, 3560, 3580, 1, + 0, 0, 0, 3561, 3562, 5, 38, 0, 0, 3562, 3563, 5, 687, 0, 0, 3563, 3565, + 5, 350, 0, 0, 3564, 3566, 3, 650, 325, 0, 3565, 3564, 1, 0, 0, 0, 3565, + 3566, 1, 0, 0, 0, 3566, 3567, 1, 0, 0, 0, 3567, 3568, 3, 856, 428, 0, 3568, + 3569, 5, 870, 0, 0, 3569, 3580, 1, 0, 0, 0, 3570, 3571, 5, 38, 0, 0, 3571, + 3572, 5, 687, 0, 0, 3572, 3574, 5, 350, 0, 0, 3573, 3575, 3, 650, 325, + 0, 3574, 3573, 1, 0, 0, 0, 3574, 3575, 1, 0, 0, 0, 3575, 3576, 1, 0, 0, + 0, 3576, 3577, 3, 856, 428, 0, 3577, 3578, 5, 703, 0, 0, 3578, 3580, 1, + 0, 0, 0, 3579, 3393, 1, 0, 0, 0, 3579, 3404, 1, 0, 0, 0, 3579, 3422, 1, + 0, 0, 0, 3579, 3448, 1, 0, 0, 0, 3579, 3460, 1, 0, 0, 0, 3579, 3475, 1, + 0, 0, 0, 3579, 3487, 1, 0, 0, 0, 3579, 3499, 1, 0, 0, 0, 3579, 3514, 1, + 0, 0, 0, 3579, 3526, 1, 0, 0, 0, 3579, 3540, 1, 0, 0, 0, 3579, 3552, 1, + 0, 0, 0, 3579, 3561, 1, 0, 0, 0, 3579, 3570, 1, 0, 0, 0, 3580, 197, 1, + 0, 0, 0, 3581, 3582, 5, 192, 0, 0, 3582, 3583, 5, 1092, 0, 0, 3583, 3584, + 3, 880, 440, 0, 3584, 199, 1, 0, 0, 0, 3585, 3586, 5, 328, 0, 0, 3586, + 3587, 5, 1092, 0, 0, 3587, 3588, 7, 19, 0, 0, 3588, 201, 1, 0, 0, 0, 3589, + 3590, 5, 517, 0, 0, 3590, 3591, 5, 1092, 0, 0, 3591, 3592, 5, 1104, 0, + 0, 3592, 3597, 3, 856, 428, 0, 3593, 3594, 5, 1110, 0, 0, 3594, 3596, 3, + 856, 428, 0, 3595, 3593, 1, 0, 0, 0, 3596, 3599, 1, 0, 0, 0, 3597, 3595, + 1, 0, 0, 0, 3597, 3598, 1, 0, 0, 0, 3598, 3600, 1, 0, 0, 0, 3599, 3597, + 1, 0, 0, 0, 3600, 3601, 5, 1105, 0, 0, 3601, 203, 1, 0, 0, 0, 3602, 3603, + 5, 553, 0, 0, 3603, 3604, 3, 880, 440, 0, 3604, 3605, 5, 592, 0, 0, 3605, + 3606, 5, 246, 0, 0, 3606, 3607, 7, 20, 0, 0, 3607, 205, 1, 0, 0, 0, 3608, + 3609, 5, 38, 0, 0, 3609, 3610, 5, 694, 0, 0, 3610, 3612, 5, 484, 0, 0, + 3611, 3613, 3, 650, 325, 0, 3612, 3611, 1, 0, 0, 0, 3612, 3613, 1, 0, 0, + 0, 3613, 3614, 1, 0, 0, 0, 3614, 3635, 3, 856, 428, 0, 3615, 3617, 5, 783, + 0, 0, 3616, 3618, 3, 198, 99, 0, 3617, 3616, 1, 0, 0, 0, 3617, 3618, 1, + 0, 0, 0, 3618, 3620, 1, 0, 0, 0, 3619, 3621, 3, 200, 100, 0, 3620, 3619, + 1, 0, 0, 0, 3620, 3621, 1, 0, 0, 0, 3621, 3628, 1, 0, 0, 0, 3622, 3623, + 5, 832, 0, 0, 3623, 3624, 5, 1092, 0, 0, 3624, 3625, 5, 1104, 0, 0, 3625, + 3629, 3, 852, 426, 0, 3626, 3627, 5, 375, 0, 0, 3627, 3629, 5, 1105, 0, + 0, 3628, 3622, 1, 0, 0, 0, 3628, 3626, 1, 0, 0, 0, 3628, 3629, 1, 0, 0, + 0, 3629, 3633, 1, 0, 0, 0, 3630, 3631, 5, 268, 0, 0, 3631, 3632, 5, 1092, + 0, 0, 3632, 3634, 3, 852, 426, 0, 3633, 3630, 1, 0, 0, 0, 3633, 3634, 1, + 0, 0, 0, 3634, 3636, 1, 0, 0, 0, 3635, 3615, 1, 0, 0, 0, 3635, 3636, 1, + 0, 0, 0, 3636, 3649, 1, 0, 0, 0, 3637, 3647, 3, 202, 101, 0, 3638, 3639, + 5, 939, 0, 0, 3639, 3644, 3, 204, 102, 0, 3640, 3641, 5, 1110, 0, 0, 3641, + 3643, 3, 204, 102, 0, 3642, 3640, 1, 0, 0, 0, 3643, 3646, 1, 0, 0, 0, 3644, + 3642, 1, 0, 0, 0, 3644, 3645, 1, 0, 0, 0, 3645, 3648, 1, 0, 0, 0, 3646, + 3644, 1, 0, 0, 0, 3647, 3638, 1, 0, 0, 0, 3647, 3648, 1, 0, 0, 0, 3648, + 3650, 1, 0, 0, 0, 3649, 3637, 1, 0, 0, 0, 3649, 3650, 1, 0, 0, 0, 3650, + 207, 1, 0, 0, 0, 3651, 3652, 5, 38, 0, 0, 3652, 3654, 5, 718, 0, 0, 3653, + 3655, 3, 650, 325, 0, 3654, 3653, 1, 0, 0, 0, 3654, 3655, 1, 0, 0, 0, 3655, + 3656, 1, 0, 0, 0, 3656, 3657, 3, 856, 428, 0, 3657, 3658, 5, 682, 0, 0, + 3658, 3659, 5, 922, 0, 0, 3659, 3660, 3, 856, 428, 0, 3660, 3696, 1, 0, + 0, 0, 3661, 3662, 5, 38, 0, 0, 3662, 3664, 5, 718, 0, 0, 3663, 3665, 3, + 650, 325, 0, 3664, 3663, 1, 0, 0, 0, 3664, 3665, 1, 0, 0, 0, 3665, 3666, + 1, 0, 0, 0, 3666, 3667, 3, 856, 428, 0, 3667, 3668, 5, 783, 0, 0, 3668, + 3669, 3, 646, 323, 0, 3669, 3696, 1, 0, 0, 0, 3670, 3671, 5, 38, 0, 0, + 3671, 3673, 5, 718, 0, 0, 3672, 3674, 3, 650, 325, 0, 3673, 3672, 1, 0, + 0, 0, 3673, 3674, 1, 0, 0, 0, 3674, 3675, 1, 0, 0, 0, 3675, 3676, 3, 856, + 428, 0, 3676, 3677, 5, 974, 0, 0, 3677, 3678, 5, 161, 0, 0, 3678, 3696, + 1, 0, 0, 0, 3679, 3680, 5, 38, 0, 0, 3680, 3682, 5, 718, 0, 0, 3681, 3683, + 3, 650, 325, 0, 3682, 3681, 1, 0, 0, 0, 3682, 3683, 1, 0, 0, 0, 3683, 3684, + 1, 0, 0, 0, 3684, 3685, 3, 856, 428, 0, 3685, 3686, 3, 300, 150, 0, 3686, + 3696, 1, 0, 0, 0, 3687, 3688, 5, 38, 0, 0, 3688, 3690, 5, 718, 0, 0, 3689, + 3691, 3, 650, 325, 0, 3690, 3689, 1, 0, 0, 0, 3690, 3691, 1, 0, 0, 0, 3691, + 3692, 1, 0, 0, 0, 3692, 3693, 3, 856, 428, 0, 3693, 3694, 3, 304, 152, + 0, 3694, 3696, 1, 0, 0, 0, 3695, 3651, 1, 0, 0, 0, 3695, 3661, 1, 0, 0, + 0, 3695, 3670, 1, 0, 0, 0, 3695, 3679, 1, 0, 0, 0, 3695, 3687, 1, 0, 0, + 0, 3696, 209, 1, 0, 0, 0, 3697, 3698, 5, 38, 0, 0, 3698, 3699, 5, 723, + 0, 0, 3699, 3700, 5, 8, 0, 0, 3700, 3702, 5, 608, 0, 0, 3701, 3703, 3, + 650, 325, 0, 3702, 3701, 1, 0, 0, 0, 3702, 3703, 1, 0, 0, 0, 3703, 3704, + 1, 0, 0, 0, 3704, 3705, 3, 856, 428, 0, 3705, 3706, 5, 783, 0, 0, 3706, + 3707, 5, 106, 0, 0, 3707, 3708, 5, 1088, 0, 0, 3708, 3709, 3, 886, 443, + 0, 3709, 3734, 1, 0, 0, 0, 3710, 3711, 5, 38, 0, 0, 3711, 3712, 5, 723, + 0, 0, 3712, 3713, 5, 8, 0, 0, 3713, 3715, 5, 608, 0, 0, 3714, 3716, 3, + 650, 325, 0, 3715, 3714, 1, 0, 0, 0, 3715, 3716, 1, 0, 0, 0, 3716, 3717, + 1, 0, 0, 0, 3717, 3718, 3, 856, 428, 0, 3718, 3719, 5, 682, 0, 0, 3719, + 3720, 5, 922, 0, 0, 3720, 3721, 3, 856, 428, 0, 3721, 3734, 1, 0, 0, 0, + 3722, 3723, 5, 38, 0, 0, 3723, 3724, 5, 723, 0, 0, 3724, 3725, 5, 8, 0, + 0, 3725, 3727, 5, 608, 0, 0, 3726, 3728, 3, 650, 325, 0, 3727, 3726, 1, + 0, 0, 0, 3727, 3728, 1, 0, 0, 0, 3728, 3729, 1, 0, 0, 0, 3729, 3730, 3, + 856, 428, 0, 3730, 3731, 5, 783, 0, 0, 3731, 3732, 3, 646, 323, 0, 3732, + 3734, 1, 0, 0, 0, 3733, 3697, 1, 0, 0, 0, 3733, 3710, 1, 0, 0, 0, 3733, + 3722, 1, 0, 0, 0, 3734, 211, 1, 0, 0, 0, 3735, 3736, 5, 38, 0, 0, 3736, + 3738, 5, 757, 0, 0, 3737, 3739, 3, 650, 325, 0, 3738, 3737, 1, 0, 0, 0, + 3738, 3739, 1, 0, 0, 0, 3739, 3740, 1, 0, 0, 0, 3740, 3741, 3, 834, 417, + 0, 3741, 3742, 5, 682, 0, 0, 3742, 3743, 5, 922, 0, 0, 3743, 3744, 3, 834, + 417, 0, 3744, 3820, 1, 0, 0, 0, 3745, 3746, 5, 38, 0, 0, 3746, 3748, 5, + 757, 0, 0, 3747, 3749, 3, 650, 325, 0, 3748, 3747, 1, 0, 0, 0, 3748, 3749, + 1, 0, 0, 0, 3749, 3750, 1, 0, 0, 0, 3750, 3751, 3, 834, 417, 0, 3751, 3752, + 5, 874, 0, 0, 3752, 3753, 5, 1020, 0, 0, 3753, 3754, 3, 834, 417, 0, 3754, + 3820, 1, 0, 0, 0, 3755, 3756, 5, 38, 0, 0, 3756, 3758, 5, 757, 0, 0, 3757, + 3759, 3, 650, 325, 0, 3758, 3757, 1, 0, 0, 0, 3758, 3759, 1, 0, 0, 0, 3759, + 3760, 1, 0, 0, 0, 3760, 3761, 3, 834, 417, 0, 3761, 3765, 5, 783, 0, 0, + 3762, 3763, 5, 209, 0, 0, 3763, 3764, 5, 1092, 0, 0, 3764, 3766, 3, 880, + 440, 0, 3765, 3762, 1, 0, 0, 0, 3765, 3766, 1, 0, 0, 0, 3766, 3770, 1, + 0, 0, 0, 3767, 3768, 5, 467, 0, 0, 3768, 3769, 5, 1092, 0, 0, 3769, 3771, + 3, 880, 440, 0, 3770, 3767, 1, 0, 0, 0, 3770, 3771, 1, 0, 0, 0, 3771, 3773, + 1, 0, 0, 0, 3772, 3774, 3, 130, 65, 0, 3773, 3772, 1, 0, 0, 0, 3773, 3774, + 1, 0, 0, 0, 3774, 3776, 1, 0, 0, 0, 3775, 3777, 3, 646, 323, 0, 3776, 3775, + 1, 0, 0, 0, 3776, 3777, 1, 0, 0, 0, 3777, 3820, 1, 0, 0, 0, 3778, 3779, + 5, 38, 0, 0, 3779, 3781, 5, 757, 0, 0, 3780, 3782, 3, 650, 325, 0, 3781, + 3780, 1, 0, 0, 0, 3781, 3782, 1, 0, 0, 0, 3782, 3783, 1, 0, 0, 0, 3783, + 3784, 3, 834, 417, 0, 3784, 3785, 3, 300, 150, 0, 3785, 3820, 1, 0, 0, + 0, 3786, 3787, 5, 38, 0, 0, 3787, 3789, 5, 757, 0, 0, 3788, 3790, 3, 650, + 325, 0, 3789, 3788, 1, 0, 0, 0, 3789, 3790, 1, 0, 0, 0, 3790, 3791, 1, + 0, 0, 0, 3791, 3792, 3, 834, 417, 0, 3792, 3793, 3, 304, 152, 0, 3793, + 3820, 1, 0, 0, 0, 3794, 3795, 5, 38, 0, 0, 3795, 3797, 5, 757, 0, 0, 3796, + 3798, 3, 650, 325, 0, 3797, 3796, 1, 0, 0, 0, 3797, 3798, 1, 0, 0, 0, 3798, + 3799, 1, 0, 0, 0, 3799, 3800, 3, 834, 417, 0, 3800, 3801, 5, 974, 0, 0, + 3801, 3806, 3, 214, 107, 0, 3802, 3803, 5, 1110, 0, 0, 3803, 3805, 3, 214, + 107, 0, 3804, 3802, 1, 0, 0, 0, 3805, 3808, 1, 0, 0, 0, 3806, 3804, 1, + 0, 0, 0, 3806, 3807, 1, 0, 0, 0, 3807, 3820, 1, 0, 0, 0, 3808, 3806, 1, + 0, 0, 0, 3809, 3810, 5, 38, 0, 0, 3810, 3812, 5, 757, 0, 0, 3811, 3813, + 3, 650, 325, 0, 3812, 3811, 1, 0, 0, 0, 3812, 3813, 1, 0, 0, 0, 3813, 3814, + 1, 0, 0, 0, 3814, 3815, 3, 834, 417, 0, 3815, 3816, 7, 21, 0, 0, 3816, + 3817, 5, 452, 0, 0, 3817, 3818, 5, 8, 0, 0, 3818, 3820, 1, 0, 0, 0, 3819, + 3735, 1, 0, 0, 0, 3819, 3745, 1, 0, 0, 0, 3819, 3755, 1, 0, 0, 0, 3819, + 3778, 1, 0, 0, 0, 3819, 3786, 1, 0, 0, 0, 3819, 3794, 1, 0, 0, 0, 3819, + 3809, 1, 0, 0, 0, 3820, 213, 1, 0, 0, 0, 3821, 3822, 7, 13, 0, 0, 3822, + 215, 1, 0, 0, 0, 3823, 3824, 5, 38, 0, 0, 3824, 3826, 5, 775, 0, 0, 3825, + 3827, 3, 650, 325, 0, 3826, 3825, 1, 0, 0, 0, 3826, 3827, 1, 0, 0, 0, 3827, + 3828, 1, 0, 0, 0, 3828, 3829, 3, 878, 439, 0, 3829, 3830, 5, 682, 0, 0, + 3830, 3831, 5, 922, 0, 0, 3831, 3832, 3, 878, 439, 0, 3832, 3871, 1, 0, + 0, 0, 3833, 3834, 5, 38, 0, 0, 3834, 3836, 5, 775, 0, 0, 3835, 3837, 3, + 650, 325, 0, 3836, 3835, 1, 0, 0, 0, 3836, 3837, 1, 0, 0, 0, 3837, 3838, + 1, 0, 0, 0, 3838, 3840, 3, 878, 439, 0, 3839, 3841, 5, 783, 0, 0, 3840, + 3839, 1, 0, 0, 0, 3840, 3841, 1, 0, 0, 0, 3841, 3850, 1, 0, 0, 0, 3842, + 3844, 5, 381, 0, 0, 3843, 3845, 5, 110, 0, 0, 3844, 3843, 1, 0, 0, 0, 3844, + 3845, 1, 0, 0, 0, 3845, 3847, 1, 0, 0, 0, 3846, 3848, 5, 1092, 0, 0, 3847, + 3846, 1, 0, 0, 0, 3847, 3848, 1, 0, 0, 0, 3848, 3849, 1, 0, 0, 0, 3849, + 3851, 3, 880, 440, 0, 3850, 3842, 1, 0, 0, 0, 3850, 3851, 1, 0, 0, 0, 3851, + 3871, 1, 0, 0, 0, 3852, 3853, 5, 38, 0, 0, 3853, 3855, 5, 775, 0, 0, 3854, + 3856, 3, 650, 325, 0, 3855, 3854, 1, 0, 0, 0, 3855, 3856, 1, 0, 0, 0, 3856, + 3857, 1, 0, 0, 0, 3857, 3858, 3, 878, 439, 0, 3858, 3859, 5, 783, 0, 0, + 3859, 3860, 3, 646, 323, 0, 3860, 3871, 1, 0, 0, 0, 3861, 3862, 5, 38, + 0, 0, 3862, 3864, 5, 775, 0, 0, 3863, 3865, 3, 650, 325, 0, 3864, 3863, + 1, 0, 0, 0, 3864, 3865, 1, 0, 0, 0, 3865, 3866, 1, 0, 0, 0, 3866, 3867, + 3, 878, 439, 0, 3867, 3868, 5, 974, 0, 0, 3868, 3869, 5, 161, 0, 0, 3869, + 3871, 1, 0, 0, 0, 3870, 3823, 1, 0, 0, 0, 3870, 3833, 1, 0, 0, 0, 3870, + 3852, 1, 0, 0, 0, 3870, 3861, 1, 0, 0, 0, 3871, 217, 1, 0, 0, 0, 3872, + 3874, 5, 38, 0, 0, 3873, 3875, 5, 770, 0, 0, 3874, 3873, 1, 0, 0, 0, 3874, + 3875, 1, 0, 0, 0, 3875, 3876, 1, 0, 0, 0, 3876, 3877, 5, 394, 0, 0, 3877, + 3878, 3, 650, 325, 0, 3878, 3879, 3, 856, 428, 0, 3879, 3883, 5, 783, 0, + 0, 3880, 3881, 5, 954, 0, 0, 3881, 3882, 5, 1092, 0, 0, 3882, 3884, 5, + 292, 0, 0, 3883, 3880, 1, 0, 0, 0, 3883, 3884, 1, 0, 0, 0, 3884, 3888, + 1, 0, 0, 0, 3885, 3886, 5, 258, 0, 0, 3886, 3887, 5, 1092, 0, 0, 3887, + 3889, 3, 450, 225, 0, 3888, 3885, 1, 0, 0, 0, 3888, 3889, 1, 0, 0, 0, 3889, + 3893, 1, 0, 0, 0, 3890, 3891, 5, 305, 0, 0, 3891, 3892, 5, 1092, 0, 0, + 3892, 3894, 7, 22, 0, 0, 3893, 3890, 1, 0, 0, 0, 3893, 3894, 1, 0, 0, 0, + 3894, 3898, 1, 0, 0, 0, 3895, 3896, 5, 298, 0, 0, 3896, 3897, 5, 1092, + 0, 0, 3897, 3899, 3, 852, 426, 0, 3898, 3895, 1, 0, 0, 0, 3898, 3899, 1, + 0, 0, 0, 3899, 3909, 1, 0, 0, 0, 3900, 3901, 5, 304, 0, 0, 3901, 3907, + 5, 1092, 0, 0, 3902, 3908, 3, 852, 426, 0, 3903, 3904, 5, 1104, 0, 0, 3904, + 3905, 3, 854, 427, 0, 3905, 3906, 5, 1105, 0, 0, 3906, 3908, 1, 0, 0, 0, + 3907, 3902, 1, 0, 0, 0, 3907, 3903, 1, 0, 0, 0, 3908, 3910, 1, 0, 0, 0, + 3909, 3900, 1, 0, 0, 0, 3909, 3910, 1, 0, 0, 0, 3910, 3914, 1, 0, 0, 0, + 3911, 3912, 5, 303, 0, 0, 3912, 3913, 5, 1092, 0, 0, 3913, 3915, 3, 852, + 426, 0, 3914, 3911, 1, 0, 0, 0, 3914, 3915, 1, 0, 0, 0, 3915, 3919, 1, + 0, 0, 0, 3916, 3917, 5, 299, 0, 0, 3917, 3918, 5, 1092, 0, 0, 3918, 3920, + 3, 852, 426, 0, 3919, 3916, 1, 0, 0, 0, 3919, 3920, 1, 0, 0, 0, 3920, 3930, + 1, 0, 0, 0, 3921, 3922, 5, 299, 0, 0, 3922, 3928, 5, 1092, 0, 0, 3923, + 3929, 3, 852, 426, 0, 3924, 3925, 5, 1104, 0, 0, 3925, 3926, 3, 854, 427, + 0, 3926, 3927, 5, 1105, 0, 0, 3927, 3929, 1, 0, 0, 0, 3928, 3923, 1, 0, + 0, 0, 3928, 3924, 1, 0, 0, 0, 3929, 3931, 1, 0, 0, 0, 3930, 3921, 1, 0, + 0, 0, 3930, 3931, 1, 0, 0, 0, 3931, 3935, 1, 0, 0, 0, 3932, 3933, 5, 300, + 0, 0, 3933, 3934, 5, 1092, 0, 0, 3934, 3936, 3, 852, 426, 0, 3935, 3932, + 1, 0, 0, 0, 3935, 3936, 1, 0, 0, 0, 3936, 3940, 1, 0, 0, 0, 3937, 3938, + 5, 301, 0, 0, 3938, 3939, 5, 1092, 0, 0, 3939, 3941, 3, 852, 426, 0, 3940, + 3937, 1, 0, 0, 0, 3940, 3941, 1, 0, 0, 0, 3941, 3948, 1, 0, 0, 0, 3942, + 3943, 5, 297, 0, 0, 3943, 3944, 5, 1092, 0, 0, 3944, 3945, 5, 1104, 0, + 0, 3945, 3946, 3, 854, 427, 0, 3946, 3947, 5, 1105, 0, 0, 3947, 3949, 1, + 0, 0, 0, 3948, 3942, 1, 0, 0, 0, 3948, 3949, 1, 0, 0, 0, 3949, 3956, 1, + 0, 0, 0, 3950, 3951, 5, 294, 0, 0, 3951, 3952, 5, 1092, 0, 0, 3952, 3953, + 5, 1104, 0, 0, 3953, 3954, 3, 854, 427, 0, 3954, 3955, 5, 1105, 0, 0, 3955, + 3957, 1, 0, 0, 0, 3956, 3950, 1, 0, 0, 0, 3956, 3957, 1, 0, 0, 0, 3957, + 3964, 1, 0, 0, 0, 3958, 3959, 5, 296, 0, 0, 3959, 3960, 5, 1092, 0, 0, + 3960, 3961, 5, 1104, 0, 0, 3961, 3962, 3, 852, 426, 0, 3962, 3963, 5, 1105, + 0, 0, 3963, 3965, 1, 0, 0, 0, 3964, 3958, 1, 0, 0, 0, 3964, 3965, 1, 0, + 0, 0, 3965, 3969, 1, 0, 0, 0, 3966, 3967, 5, 295, 0, 0, 3967, 3968, 5, + 1092, 0, 0, 3968, 3970, 7, 23, 0, 0, 3969, 3966, 1, 0, 0, 0, 3969, 3970, + 1, 0, 0, 0, 3970, 3974, 1, 0, 0, 0, 3971, 3972, 5, 295, 0, 0, 3972, 3973, + 5, 1092, 0, 0, 3973, 3975, 3, 852, 426, 0, 3974, 3971, 1, 0, 0, 0, 3974, + 3975, 1, 0, 0, 0, 3975, 4011, 1, 0, 0, 0, 3976, 3978, 5, 38, 0, 0, 3977, + 3979, 5, 770, 0, 0, 3978, 3977, 1, 0, 0, 0, 3978, 3979, 1, 0, 0, 0, 3979, + 3980, 1, 0, 0, 0, 3980, 3982, 5, 394, 0, 0, 3981, 3983, 3, 650, 325, 0, + 3982, 3981, 1, 0, 0, 0, 3982, 3983, 1, 0, 0, 0, 3983, 3984, 1, 0, 0, 0, + 3984, 3985, 3, 856, 428, 0, 3985, 3986, 5, 974, 0, 0, 3986, 3991, 3, 220, + 110, 0, 3987, 3988, 5, 1110, 0, 0, 3988, 3990, 3, 220, 110, 0, 3989, 3987, + 1, 0, 0, 0, 3990, 3993, 1, 0, 0, 0, 3991, 3989, 1, 0, 0, 0, 3991, 3992, + 1, 0, 0, 0, 3992, 4011, 1, 0, 0, 0, 3993, 3991, 1, 0, 0, 0, 3994, 3996, + 5, 38, 0, 0, 3995, 3997, 5, 770, 0, 0, 3996, 3995, 1, 0, 0, 0, 3996, 3997, + 1, 0, 0, 0, 3997, 3998, 1, 0, 0, 0, 3998, 3999, 5, 394, 0, 0, 3999, 4000, + 3, 856, 428, 0, 4000, 4001, 3, 300, 150, 0, 4001, 4011, 1, 0, 0, 0, 4002, + 4004, 5, 38, 0, 0, 4003, 4005, 5, 770, 0, 0, 4004, 4003, 1, 0, 0, 0, 4004, + 4005, 1, 0, 0, 0, 4005, 4006, 1, 0, 0, 0, 4006, 4007, 5, 394, 0, 0, 4007, + 4008, 3, 856, 428, 0, 4008, 4009, 3, 304, 152, 0, 4009, 4011, 1, 0, 0, + 0, 4010, 3872, 1, 0, 0, 0, 4010, 3976, 1, 0, 0, 0, 4010, 3994, 1, 0, 0, + 0, 4010, 4002, 1, 0, 0, 0, 4011, 219, 1, 0, 0, 0, 4012, 4021, 5, 258, 0, + 0, 4013, 4021, 5, 497, 0, 0, 4014, 4021, 5, 531, 0, 0, 4015, 4021, 5, 532, + 0, 0, 4016, 4017, 5, 537, 0, 0, 4017, 4018, 5, 1092, 0, 0, 4018, 4021, + 7, 24, 0, 0, 4019, 4021, 5, 161, 0, 0, 4020, 4012, 1, 0, 0, 0, 4020, 4013, + 1, 0, 0, 0, 4020, 4014, 1, 0, 0, 0, 4020, 4015, 1, 0, 0, 0, 4020, 4016, + 1, 0, 0, 0, 4020, 4019, 1, 0, 0, 0, 4021, 221, 1, 0, 0, 0, 4022, 4024, + 5, 38, 0, 0, 4023, 4025, 5, 770, 0, 0, 4024, 4023, 1, 0, 0, 0, 4024, 4025, + 1, 0, 0, 0, 4025, 4026, 1, 0, 0, 0, 4026, 4028, 5, 394, 0, 0, 4027, 4029, + 3, 650, 325, 0, 4028, 4027, 1, 0, 0, 0, 4028, 4029, 1, 0, 0, 0, 4029, 4030, + 1, 0, 0, 0, 4030, 4031, 3, 856, 428, 0, 4031, 4035, 5, 783, 0, 0, 4032, + 4033, 5, 954, 0, 0, 4033, 4034, 5, 1092, 0, 0, 4034, 4036, 5, 292, 0, 0, + 4035, 4032, 1, 0, 0, 0, 4035, 4036, 1, 0, 0, 0, 4036, 4038, 1, 0, 0, 0, + 4037, 4039, 3, 138, 69, 0, 4038, 4037, 1, 0, 0, 0, 4038, 4039, 1, 0, 0, + 0, 4039, 4043, 1, 0, 0, 0, 4040, 4041, 5, 305, 0, 0, 4041, 4042, 5, 1092, + 0, 0, 4042, 4044, 7, 22, 0, 0, 4043, 4040, 1, 0, 0, 0, 4043, 4044, 1, 0, + 0, 0, 4044, 4048, 1, 0, 0, 0, 4045, 4046, 5, 298, 0, 0, 4046, 4047, 5, + 1092, 0, 0, 4047, 4049, 3, 852, 426, 0, 4048, 4045, 1, 0, 0, 0, 4048, 4049, + 1, 0, 0, 0, 4049, 4059, 1, 0, 0, 0, 4050, 4051, 5, 304, 0, 0, 4051, 4057, + 5, 1092, 0, 0, 4052, 4058, 3, 852, 426, 0, 4053, 4054, 5, 1104, 0, 0, 4054, + 4055, 3, 854, 427, 0, 4055, 4056, 5, 1105, 0, 0, 4056, 4058, 1, 0, 0, 0, + 4057, 4052, 1, 0, 0, 0, 4057, 4053, 1, 0, 0, 0, 4058, 4060, 1, 0, 0, 0, + 4059, 4050, 1, 0, 0, 0, 4059, 4060, 1, 0, 0, 0, 4060, 4064, 1, 0, 0, 0, + 4061, 4062, 5, 303, 0, 0, 4062, 4063, 5, 1092, 0, 0, 4063, 4065, 3, 852, + 426, 0, 4064, 4061, 1, 0, 0, 0, 4064, 4065, 1, 0, 0, 0, 4065, 4069, 1, + 0, 0, 0, 4066, 4067, 5, 299, 0, 0, 4067, 4068, 5, 1092, 0, 0, 4068, 4070, + 3, 852, 426, 0, 4069, 4066, 1, 0, 0, 0, 4069, 4070, 1, 0, 0, 0, 4070, 4080, + 1, 0, 0, 0, 4071, 4072, 5, 299, 0, 0, 4072, 4078, 5, 1092, 0, 0, 4073, + 4079, 3, 852, 426, 0, 4074, 4075, 5, 1104, 0, 0, 4075, 4076, 3, 854, 427, + 0, 4076, 4077, 5, 1105, 0, 0, 4077, 4079, 1, 0, 0, 0, 4078, 4073, 1, 0, + 0, 0, 4078, 4074, 1, 0, 0, 0, 4079, 4081, 1, 0, 0, 0, 4080, 4071, 1, 0, + 0, 0, 4080, 4081, 1, 0, 0, 0, 4081, 4085, 1, 0, 0, 0, 4082, 4083, 5, 300, + 0, 0, 4083, 4084, 5, 1092, 0, 0, 4084, 4086, 3, 852, 426, 0, 4085, 4082, + 1, 0, 0, 0, 4085, 4086, 1, 0, 0, 0, 4086, 4090, 1, 0, 0, 0, 4087, 4088, + 5, 301, 0, 0, 4088, 4089, 5, 1092, 0, 0, 4089, 4091, 3, 852, 426, 0, 4090, + 4087, 1, 0, 0, 0, 4090, 4091, 1, 0, 0, 0, 4091, 4098, 1, 0, 0, 0, 4092, + 4093, 5, 297, 0, 0, 4093, 4094, 5, 1092, 0, 0, 4094, 4095, 5, 1104, 0, + 0, 4095, 4096, 3, 854, 427, 0, 4096, 4097, 5, 1105, 0, 0, 4097, 4099, 1, + 0, 0, 0, 4098, 4092, 1, 0, 0, 0, 4098, 4099, 1, 0, 0, 0, 4099, 4106, 1, + 0, 0, 0, 4100, 4101, 5, 294, 0, 0, 4101, 4102, 5, 1092, 0, 0, 4102, 4103, + 5, 1104, 0, 0, 4103, 4104, 3, 854, 427, 0, 4104, 4105, 5, 1105, 0, 0, 4105, + 4107, 1, 0, 0, 0, 4106, 4100, 1, 0, 0, 0, 4106, 4107, 1, 0, 0, 0, 4107, + 4114, 1, 0, 0, 0, 4108, 4109, 5, 296, 0, 0, 4109, 4110, 5, 1092, 0, 0, + 4110, 4111, 5, 1104, 0, 0, 4111, 4112, 3, 852, 426, 0, 4112, 4113, 5, 1105, + 0, 0, 4113, 4115, 1, 0, 0, 0, 4114, 4108, 1, 0, 0, 0, 4114, 4115, 1, 0, + 0, 0, 4115, 4121, 1, 0, 0, 0, 4116, 4117, 5, 295, 0, 0, 4117, 4118, 5, + 1092, 0, 0, 4118, 4122, 5, 239, 0, 0, 4119, 4122, 5, 257, 0, 0, 4120, 4122, + 5, 259, 0, 0, 4121, 4116, 1, 0, 0, 0, 4121, 4119, 1, 0, 0, 0, 4121, 4120, + 1, 0, 0, 0, 4121, 4122, 1, 0, 0, 0, 4122, 4123, 1, 0, 0, 0, 4123, 4124, + 5, 302, 0, 0, 4124, 4125, 5, 1092, 0, 0, 4125, 4126, 3, 852, 426, 0, 4126, + 4162, 1, 0, 0, 0, 4127, 4129, 5, 38, 0, 0, 4128, 4130, 5, 770, 0, 0, 4129, + 4128, 1, 0, 0, 0, 4129, 4130, 1, 0, 0, 0, 4130, 4131, 1, 0, 0, 0, 4131, + 4133, 5, 394, 0, 0, 4132, 4134, 3, 650, 325, 0, 4133, 4132, 1, 0, 0, 0, + 4133, 4134, 1, 0, 0, 0, 4134, 4135, 1, 0, 0, 0, 4135, 4136, 3, 856, 428, + 0, 4136, 4137, 5, 974, 0, 0, 4137, 4142, 3, 224, 112, 0, 4138, 4139, 5, + 1110, 0, 0, 4139, 4141, 3, 224, 112, 0, 4140, 4138, 1, 0, 0, 0, 4141, 4144, + 1, 0, 0, 0, 4142, 4140, 1, 0, 0, 0, 4142, 4143, 1, 0, 0, 0, 4143, 4162, + 1, 0, 0, 0, 4144, 4142, 1, 0, 0, 0, 4145, 4147, 5, 38, 0, 0, 4146, 4148, + 5, 770, 0, 0, 4147, 4146, 1, 0, 0, 0, 4147, 4148, 1, 0, 0, 0, 4148, 4149, + 1, 0, 0, 0, 4149, 4150, 5, 394, 0, 0, 4150, 4151, 3, 856, 428, 0, 4151, + 4152, 3, 300, 150, 0, 4152, 4162, 1, 0, 0, 0, 4153, 4155, 5, 38, 0, 0, + 4154, 4156, 5, 770, 0, 0, 4155, 4154, 1, 0, 0, 0, 4155, 4156, 1, 0, 0, + 0, 4156, 4157, 1, 0, 0, 0, 4157, 4158, 5, 394, 0, 0, 4158, 4159, 3, 856, + 428, 0, 4159, 4160, 3, 304, 152, 0, 4160, 4162, 1, 0, 0, 0, 4161, 4022, + 1, 0, 0, 0, 4161, 4127, 1, 0, 0, 0, 4161, 4145, 1, 0, 0, 0, 4161, 4153, + 1, 0, 0, 0, 4162, 223, 1, 0, 0, 0, 4163, 4164, 7, 25, 0, 0, 4164, 225, + 1, 0, 0, 0, 4165, 4167, 5, 38, 0, 0, 4166, 4168, 5, 770, 0, 0, 4167, 4166, + 1, 0, 0, 0, 4167, 4168, 1, 0, 0, 0, 4168, 4169, 1, 0, 0, 0, 4169, 4171, + 5, 394, 0, 0, 4170, 4172, 3, 650, 325, 0, 4171, 4170, 1, 0, 0, 0, 4171, + 4172, 1, 0, 0, 0, 4172, 4173, 1, 0, 0, 0, 4173, 4174, 3, 856, 428, 0, 4174, + 4178, 5, 783, 0, 0, 4175, 4176, 5, 954, 0, 0, 4176, 4177, 5, 1092, 0, 0, + 4177, 4179, 5, 737, 0, 0, 4178, 4175, 1, 0, 0, 0, 4178, 4179, 1, 0, 0, + 0, 4179, 4181, 1, 0, 0, 0, 4180, 4182, 3, 138, 69, 0, 4181, 4180, 1, 0, + 0, 0, 4181, 4182, 1, 0, 0, 0, 4182, 4186, 1, 0, 0, 0, 4183, 4184, 5, 740, + 0, 0, 4184, 4185, 5, 1092, 0, 0, 4185, 4187, 3, 852, 426, 0, 4186, 4183, + 1, 0, 0, 0, 4186, 4187, 1, 0, 0, 0, 4187, 4191, 1, 0, 0, 0, 4188, 4189, + 5, 749, 0, 0, 4189, 4190, 5, 1092, 0, 0, 4190, 4192, 3, 852, 426, 0, 4191, + 4188, 1, 0, 0, 0, 4191, 4192, 1, 0, 0, 0, 4192, 4196, 1, 0, 0, 0, 4193, + 4194, 5, 742, 0, 0, 4194, 4195, 5, 1092, 0, 0, 4195, 4197, 3, 852, 426, + 0, 4196, 4193, 1, 0, 0, 0, 4196, 4197, 1, 0, 0, 0, 4197, 4201, 1, 0, 0, + 0, 4198, 4199, 5, 750, 0, 0, 4199, 4200, 5, 1092, 0, 0, 4200, 4202, 3, + 852, 426, 0, 4201, 4198, 1, 0, 0, 0, 4201, 4202, 1, 0, 0, 0, 4202, 4206, + 1, 0, 0, 0, 4203, 4204, 5, 748, 0, 0, 4204, 4205, 5, 1092, 0, 0, 4205, + 4207, 3, 852, 426, 0, 4206, 4203, 1, 0, 0, 0, 4206, 4207, 1, 0, 0, 0, 4207, + 4211, 1, 0, 0, 0, 4208, 4209, 5, 738, 0, 0, 4209, 4210, 5, 1092, 0, 0, + 4210, 4212, 3, 450, 225, 0, 4211, 4208, 1, 0, 0, 0, 4211, 4212, 1, 0, 0, + 0, 4212, 4216, 1, 0, 0, 0, 4213, 4214, 5, 747, 0, 0, 4214, 4215, 5, 1092, + 0, 0, 4215, 4217, 3, 852, 426, 0, 4216, 4213, 1, 0, 0, 0, 4216, 4217, 1, + 0, 0, 0, 4217, 4221, 1, 0, 0, 0, 4218, 4219, 5, 744, 0, 0, 4219, 4220, + 5, 1092, 0, 0, 4220, 4222, 3, 450, 225, 0, 4221, 4218, 1, 0, 0, 0, 4221, + 4222, 1, 0, 0, 0, 4222, 4226, 1, 0, 0, 0, 4223, 4224, 5, 743, 0, 0, 4224, + 4225, 5, 1092, 0, 0, 4225, 4227, 3, 852, 426, 0, 4226, 4223, 1, 0, 0, 0, + 4226, 4227, 1, 0, 0, 0, 4227, 4231, 1, 0, 0, 0, 4228, 4229, 5, 741, 0, + 0, 4229, 4230, 5, 1092, 0, 0, 4230, 4232, 3, 852, 426, 0, 4231, 4228, 1, + 0, 0, 0, 4231, 4232, 1, 0, 0, 0, 4232, 4236, 1, 0, 0, 0, 4233, 4234, 5, + 739, 0, 0, 4234, 4235, 5, 1092, 0, 0, 4235, 4237, 3, 450, 225, 0, 4236, + 4233, 1, 0, 0, 0, 4236, 4237, 1, 0, 0, 0, 4237, 4241, 1, 0, 0, 0, 4238, + 4239, 5, 746, 0, 0, 4239, 4240, 5, 1092, 0, 0, 4240, 4242, 3, 852, 426, + 0, 4241, 4238, 1, 0, 0, 0, 4241, 4242, 1, 0, 0, 0, 4242, 4246, 1, 0, 0, + 0, 4243, 4244, 5, 745, 0, 0, 4244, 4245, 5, 1092, 0, 0, 4245, 4247, 3, + 852, 426, 0, 4246, 4243, 1, 0, 0, 0, 4246, 4247, 1, 0, 0, 0, 4247, 4277, + 1, 0, 0, 0, 4248, 4250, 5, 38, 0, 0, 4249, 4251, 5, 770, 0, 0, 4250, 4249, + 1, 0, 0, 0, 4250, 4251, 1, 0, 0, 0, 4251, 4252, 1, 0, 0, 0, 4252, 4254, + 5, 394, 0, 0, 4253, 4255, 3, 650, 325, 0, 4254, 4253, 1, 0, 0, 0, 4254, + 4255, 1, 0, 0, 0, 4255, 4256, 1, 0, 0, 0, 4256, 4257, 3, 856, 428, 0, 4257, + 4258, 5, 974, 0, 0, 4258, 4259, 5, 258, 0, 0, 4259, 4277, 1, 0, 0, 0, 4260, + 4262, 5, 38, 0, 0, 4261, 4263, 5, 770, 0, 0, 4262, 4261, 1, 0, 0, 0, 4262, + 4263, 1, 0, 0, 0, 4263, 4264, 1, 0, 0, 0, 4264, 4265, 5, 394, 0, 0, 4265, + 4266, 3, 856, 428, 0, 4266, 4267, 3, 300, 150, 0, 4267, 4277, 1, 0, 0, + 0, 4268, 4270, 5, 38, 0, 0, 4269, 4271, 5, 770, 0, 0, 4270, 4269, 1, 0, + 0, 0, 4270, 4271, 1, 0, 0, 0, 4271, 4272, 1, 0, 0, 0, 4272, 4273, 5, 394, + 0, 0, 4273, 4274, 3, 856, 428, 0, 4274, 4275, 3, 304, 152, 0, 4275, 4277, + 1, 0, 0, 0, 4276, 4165, 1, 0, 0, 0, 4276, 4248, 1, 0, 0, 0, 4276, 4260, + 1, 0, 0, 0, 4276, 4268, 1, 0, 0, 0, 4277, 227, 1, 0, 0, 0, 4278, 4280, + 5, 38, 0, 0, 4279, 4281, 5, 770, 0, 0, 4280, 4279, 1, 0, 0, 0, 4280, 4281, + 1, 0, 0, 0, 4281, 4282, 1, 0, 0, 0, 4282, 4284, 5, 394, 0, 0, 4283, 4285, + 3, 650, 325, 0, 4284, 4283, 1, 0, 0, 0, 4284, 4285, 1, 0, 0, 0, 4285, 4286, + 1, 0, 0, 0, 4286, 4287, 3, 856, 428, 0, 4287, 4291, 5, 783, 0, 0, 4288, + 4289, 5, 497, 0, 0, 4289, 4290, 5, 1092, 0, 0, 4290, 4292, 3, 852, 426, + 0, 4291, 4288, 1, 0, 0, 0, 4291, 4292, 1, 0, 0, 0, 4292, 4296, 1, 0, 0, + 0, 4293, 4294, 5, 876, 0, 0, 4294, 4295, 5, 1092, 0, 0, 4295, 4297, 3, + 450, 225, 0, 4296, 4293, 1, 0, 0, 0, 4296, 4297, 1, 0, 0, 0, 4297, 4299, + 1, 0, 0, 0, 4298, 4300, 3, 646, 323, 0, 4299, 4298, 1, 0, 0, 0, 4299, 4300, + 1, 0, 0, 0, 4300, 4336, 1, 0, 0, 0, 4301, 4303, 5, 38, 0, 0, 4302, 4304, + 5, 770, 0, 0, 4303, 4302, 1, 0, 0, 0, 4303, 4304, 1, 0, 0, 0, 4304, 4305, + 1, 0, 0, 0, 4305, 4307, 5, 394, 0, 0, 4306, 4308, 3, 650, 325, 0, 4307, + 4306, 1, 0, 0, 0, 4307, 4308, 1, 0, 0, 0, 4308, 4309, 1, 0, 0, 0, 4309, + 4310, 3, 856, 428, 0, 4310, 4311, 5, 974, 0, 0, 4311, 4316, 3, 230, 115, + 0, 4312, 4313, 5, 1110, 0, 0, 4313, 4315, 3, 230, 115, 0, 4314, 4312, 1, + 0, 0, 0, 4315, 4318, 1, 0, 0, 0, 4316, 4314, 1, 0, 0, 0, 4316, 4317, 1, + 0, 0, 0, 4317, 4336, 1, 0, 0, 0, 4318, 4316, 1, 0, 0, 0, 4319, 4321, 5, + 38, 0, 0, 4320, 4322, 5, 770, 0, 0, 4321, 4320, 1, 0, 0, 0, 4321, 4322, + 1, 0, 0, 0, 4322, 4323, 1, 0, 0, 0, 4323, 4324, 5, 394, 0, 0, 4324, 4325, + 3, 856, 428, 0, 4325, 4326, 3, 300, 150, 0, 4326, 4336, 1, 0, 0, 0, 4327, + 4329, 5, 38, 0, 0, 4328, 4330, 5, 770, 0, 0, 4329, 4328, 1, 0, 0, 0, 4329, + 4330, 1, 0, 0, 0, 4330, 4331, 1, 0, 0, 0, 4331, 4332, 5, 394, 0, 0, 4332, + 4333, 3, 856, 428, 0, 4333, 4334, 3, 304, 152, 0, 4334, 4336, 1, 0, 0, + 0, 4335, 4278, 1, 0, 0, 0, 4335, 4301, 1, 0, 0, 0, 4335, 4319, 1, 0, 0, + 0, 4335, 4327, 1, 0, 0, 0, 4336, 229, 1, 0, 0, 0, 4337, 4338, 7, 26, 0, + 0, 4338, 231, 1, 0, 0, 0, 4339, 4340, 5, 38, 0, 0, 4340, 4342, 5, 775, + 0, 0, 4341, 4343, 3, 650, 325, 0, 4342, 4341, 1, 0, 0, 0, 4342, 4343, 1, + 0, 0, 0, 4343, 4344, 1, 0, 0, 0, 4344, 4345, 3, 856, 428, 0, 4345, 4346, + 5, 682, 0, 0, 4346, 4347, 5, 922, 0, 0, 4347, 4348, 3, 856, 428, 0, 4348, + 4387, 1, 0, 0, 0, 4349, 4350, 5, 38, 0, 0, 4350, 4352, 5, 775, 0, 0, 4351, + 4353, 3, 650, 325, 0, 4352, 4351, 1, 0, 0, 0, 4352, 4353, 1, 0, 0, 0, 4353, + 4354, 1, 0, 0, 0, 4354, 4356, 3, 856, 428, 0, 4355, 4357, 5, 783, 0, 0, + 4356, 4355, 1, 0, 0, 0, 4356, 4357, 1, 0, 0, 0, 4357, 4366, 1, 0, 0, 0, + 4358, 4360, 5, 381, 0, 0, 4359, 4361, 5, 110, 0, 0, 4360, 4359, 1, 0, 0, + 0, 4360, 4361, 1, 0, 0, 0, 4361, 4363, 1, 0, 0, 0, 4362, 4364, 5, 1092, + 0, 0, 4363, 4362, 1, 0, 0, 0, 4363, 4364, 1, 0, 0, 0, 4364, 4365, 1, 0, + 0, 0, 4365, 4367, 3, 880, 440, 0, 4366, 4358, 1, 0, 0, 0, 4366, 4367, 1, + 0, 0, 0, 4367, 4387, 1, 0, 0, 0, 4368, 4369, 5, 38, 0, 0, 4369, 4371, 5, + 775, 0, 0, 4370, 4372, 3, 650, 325, 0, 4371, 4370, 1, 0, 0, 0, 4371, 4372, + 1, 0, 0, 0, 4372, 4373, 1, 0, 0, 0, 4373, 4374, 3, 856, 428, 0, 4374, 4375, + 5, 783, 0, 0, 4375, 4376, 3, 646, 323, 0, 4376, 4387, 1, 0, 0, 0, 4377, + 4378, 5, 38, 0, 0, 4378, 4380, 5, 775, 0, 0, 4379, 4381, 3, 650, 325, 0, + 4380, 4379, 1, 0, 0, 0, 4380, 4381, 1, 0, 0, 0, 4381, 4382, 1, 0, 0, 0, + 4382, 4383, 3, 856, 428, 0, 4383, 4384, 5, 974, 0, 0, 4384, 4385, 5, 161, + 0, 0, 4385, 4387, 1, 0, 0, 0, 4386, 4339, 1, 0, 0, 0, 4386, 4349, 1, 0, + 0, 0, 4386, 4368, 1, 0, 0, 0, 4386, 4377, 1, 0, 0, 0, 4387, 233, 1, 0, + 0, 0, 4388, 4389, 5, 38, 0, 0, 4389, 4390, 5, 779, 0, 0, 4390, 4391, 5, + 783, 0, 0, 4391, 4404, 3, 134, 67, 0, 4392, 4393, 5, 38, 0, 0, 4393, 4394, + 5, 779, 0, 0, 4394, 4395, 5, 974, 0, 0, 4395, 4400, 3, 846, 423, 0, 4396, + 4397, 5, 1110, 0, 0, 4397, 4399, 3, 846, 423, 0, 4398, 4396, 1, 0, 0, 0, + 4399, 4402, 1, 0, 0, 0, 4400, 4398, 1, 0, 0, 0, 4400, 4401, 1, 0, 0, 0, + 4401, 4404, 1, 0, 0, 0, 4402, 4400, 1, 0, 0, 0, 4403, 4388, 1, 0, 0, 0, + 4403, 4392, 1, 0, 0, 0, 4404, 235, 1, 0, 0, 0, 4405, 4406, 5, 38, 0, 0, + 4406, 4407, 5, 779, 0, 0, 4407, 4409, 5, 608, 0, 0, 4408, 4410, 3, 650, + 325, 0, 4409, 4408, 1, 0, 0, 0, 4409, 4410, 1, 0, 0, 0, 4410, 4411, 1, + 0, 0, 0, 4411, 4412, 3, 856, 428, 0, 4412, 4416, 7, 27, 0, 0, 4413, 4414, + 5, 780, 0, 0, 4414, 4415, 5, 1092, 0, 0, 4415, 4417, 3, 880, 440, 0, 4416, + 4413, 1, 0, 0, 0, 4416, 4417, 1, 0, 0, 0, 4417, 4421, 1, 0, 0, 0, 4418, + 4419, 5, 782, 0, 0, 4419, 4420, 5, 1092, 0, 0, 4420, 4422, 3, 880, 440, + 0, 4421, 4418, 1, 0, 0, 0, 4421, 4422, 1, 0, 0, 0, 4422, 4424, 1, 0, 0, + 0, 4423, 4425, 3, 646, 323, 0, 4424, 4423, 1, 0, 0, 0, 4424, 4425, 1, 0, + 0, 0, 4425, 4438, 1, 0, 0, 0, 4426, 4427, 5, 38, 0, 0, 4427, 4428, 5, 779, + 0, 0, 4428, 4430, 5, 608, 0, 0, 4429, 4431, 3, 650, 325, 0, 4430, 4429, + 1, 0, 0, 0, 4430, 4431, 1, 0, 0, 0, 4431, 4432, 1, 0, 0, 0, 4432, 4433, + 3, 856, 428, 0, 4433, 4434, 5, 682, 0, 0, 4434, 4435, 5, 922, 0, 0, 4435, + 4436, 3, 856, 428, 0, 4436, 4438, 1, 0, 0, 0, 4437, 4405, 1, 0, 0, 0, 4437, + 4426, 1, 0, 0, 0, 4438, 237, 1, 0, 0, 0, 4439, 4440, 5, 38, 0, 0, 4440, + 4442, 5, 786, 0, 0, 4441, 4443, 3, 650, 325, 0, 4442, 4441, 1, 0, 0, 0, + 4442, 4443, 1, 0, 0, 0, 4443, 4444, 1, 0, 0, 0, 4444, 4445, 3, 856, 428, + 0, 4445, 4446, 7, 28, 0, 0, 4446, 4447, 5, 11, 0, 0, 4447, 4448, 5, 1092, + 0, 0, 4448, 4453, 3, 856, 428, 0, 4449, 4450, 5, 1110, 0, 0, 4450, 4452, + 3, 856, 428, 0, 4451, 4449, 1, 0, 0, 0, 4452, 4455, 1, 0, 0, 0, 4453, 4451, + 1, 0, 0, 0, 4453, 4454, 1, 0, 0, 0, 4454, 4459, 1, 0, 0, 0, 4455, 4453, + 1, 0, 0, 0, 4456, 4457, 5, 789, 0, 0, 4457, 4458, 5, 1092, 0, 0, 4458, + 4460, 3, 450, 225, 0, 4459, 4456, 1, 0, 0, 0, 4459, 4460, 1, 0, 0, 0, 4460, + 4528, 1, 0, 0, 0, 4461, 4462, 5, 38, 0, 0, 4462, 4464, 5, 786, 0, 0, 4463, + 4465, 3, 650, 325, 0, 4464, 4463, 1, 0, 0, 0, 4464, 4465, 1, 0, 0, 0, 4465, + 4466, 1, 0, 0, 0, 4466, 4467, 3, 856, 428, 0, 4467, 4468, 5, 14, 0, 0, + 4468, 4469, 5, 11, 0, 0, 4469, 4470, 5, 1092, 0, 0, 4470, 4475, 3, 856, + 428, 0, 4471, 4472, 5, 1110, 0, 0, 4472, 4474, 3, 856, 428, 0, 4473, 4471, + 1, 0, 0, 0, 4474, 4477, 1, 0, 0, 0, 4475, 4473, 1, 0, 0, 0, 4475, 4476, + 1, 0, 0, 0, 4476, 4481, 1, 0, 0, 0, 4477, 4475, 1, 0, 0, 0, 4478, 4479, + 5, 789, 0, 0, 4479, 4480, 5, 1092, 0, 0, 4480, 4482, 3, 450, 225, 0, 4481, + 4478, 1, 0, 0, 0, 4481, 4482, 1, 0, 0, 0, 4482, 4528, 1, 0, 0, 0, 4483, + 4484, 5, 38, 0, 0, 4484, 4486, 5, 786, 0, 0, 4485, 4487, 3, 650, 325, 0, + 4486, 4485, 1, 0, 0, 0, 4486, 4487, 1, 0, 0, 0, 4487, 4488, 1, 0, 0, 0, + 4488, 4489, 3, 856, 428, 0, 4489, 4500, 5, 783, 0, 0, 4490, 4491, 5, 11, + 0, 0, 4491, 4492, 5, 1092, 0, 0, 4492, 4497, 3, 856, 428, 0, 4493, 4494, + 5, 1110, 0, 0, 4494, 4496, 3, 856, 428, 0, 4495, 4493, 1, 0, 0, 0, 4496, + 4499, 1, 0, 0, 0, 4497, 4495, 1, 0, 0, 0, 4497, 4498, 1, 0, 0, 0, 4498, + 4501, 1, 0, 0, 0, 4499, 4497, 1, 0, 0, 0, 4500, 4490, 1, 0, 0, 0, 4500, + 4501, 1, 0, 0, 0, 4501, 4503, 1, 0, 0, 0, 4502, 4504, 3, 646, 323, 0, 4503, + 4502, 1, 0, 0, 0, 4503, 4504, 1, 0, 0, 0, 4504, 4528, 1, 0, 0, 0, 4505, + 4506, 5, 38, 0, 0, 4506, 4508, 5, 786, 0, 0, 4507, 4509, 3, 650, 325, 0, + 4508, 4507, 1, 0, 0, 0, 4508, 4509, 1, 0, 0, 0, 4509, 4510, 1, 0, 0, 0, + 4510, 4511, 3, 856, 428, 0, 4511, 4512, 3, 300, 150, 0, 4512, 4528, 1, + 0, 0, 0, 4513, 4514, 5, 38, 0, 0, 4514, 4515, 5, 786, 0, 0, 4515, 4516, + 3, 856, 428, 0, 4516, 4517, 3, 304, 152, 0, 4517, 4528, 1, 0, 0, 0, 4518, + 4519, 5, 38, 0, 0, 4519, 4521, 5, 786, 0, 0, 4520, 4522, 3, 650, 325, 0, + 4521, 4520, 1, 0, 0, 0, 4521, 4522, 1, 0, 0, 0, 4522, 4523, 1, 0, 0, 0, + 4523, 4524, 3, 856, 428, 0, 4524, 4525, 5, 974, 0, 0, 4525, 4526, 5, 161, + 0, 0, 4526, 4528, 1, 0, 0, 0, 4527, 4439, 1, 0, 0, 0, 4527, 4461, 1, 0, + 0, 0, 4527, 4483, 1, 0, 0, 0, 4527, 4505, 1, 0, 0, 0, 4527, 4513, 1, 0, + 0, 0, 4527, 4518, 1, 0, 0, 0, 4528, 239, 1, 0, 0, 0, 4529, 4530, 5, 38, + 0, 0, 4530, 4532, 5, 822, 0, 0, 4531, 4533, 3, 650, 325, 0, 4532, 4531, + 1, 0, 0, 0, 4532, 4533, 1, 0, 0, 0, 4533, 4534, 1, 0, 0, 0, 4534, 4535, + 3, 856, 428, 0, 4535, 4536, 5, 682, 0, 0, 4536, 4537, 5, 922, 0, 0, 4537, + 4538, 3, 856, 428, 0, 4538, 4600, 1, 0, 0, 0, 4539, 4540, 5, 38, 0, 0, + 4540, 4542, 5, 822, 0, 0, 4541, 4543, 3, 650, 325, 0, 4542, 4541, 1, 0, + 0, 0, 4542, 4543, 1, 0, 0, 0, 4543, 4544, 1, 0, 0, 0, 4544, 4545, 3, 856, + 428, 0, 4545, 4546, 3, 300, 150, 0, 4546, 4600, 1, 0, 0, 0, 4547, 4548, + 5, 38, 0, 0, 4548, 4549, 5, 822, 0, 0, 4549, 4550, 3, 856, 428, 0, 4550, + 4551, 3, 304, 152, 0, 4551, 4600, 1, 0, 0, 0, 4552, 4553, 5, 38, 0, 0, + 4553, 4555, 5, 822, 0, 0, 4554, 4556, 3, 650, 325, 0, 4555, 4554, 1, 0, + 0, 0, 4555, 4556, 1, 0, 0, 0, 4556, 4557, 1, 0, 0, 0, 4557, 4558, 3, 856, + 428, 0, 4558, 4560, 5, 783, 0, 0, 4559, 4561, 3, 430, 215, 0, 4560, 4559, + 1, 0, 0, 0, 4560, 4561, 1, 0, 0, 0, 4561, 4563, 1, 0, 0, 0, 4562, 4564, + 3, 44, 22, 0, 4563, 4562, 1, 0, 0, 0, 4563, 4564, 1, 0, 0, 0, 4564, 4571, + 1, 0, 0, 0, 4565, 4566, 5, 187, 0, 0, 4566, 4567, 5, 1092, 0, 0, 4567, + 4568, 5, 1104, 0, 0, 4568, 4569, 3, 428, 214, 0, 4569, 4570, 5, 1105, 0, + 0, 4570, 4572, 1, 0, 0, 0, 4571, 4565, 1, 0, 0, 0, 4571, 4572, 1, 0, 0, + 0, 4572, 4573, 1, 0, 0, 0, 4573, 4574, 3, 646, 323, 0, 4574, 4600, 1, 0, + 0, 0, 4575, 4576, 5, 38, 0, 0, 4576, 4578, 5, 822, 0, 0, 4577, 4579, 3, + 650, 325, 0, 4578, 4577, 1, 0, 0, 0, 4578, 4579, 1, 0, 0, 0, 4579, 4580, + 1, 0, 0, 0, 4580, 4581, 3, 856, 428, 0, 4581, 4583, 5, 783, 0, 0, 4582, + 4584, 3, 448, 224, 0, 4583, 4582, 1, 0, 0, 0, 4583, 4584, 1, 0, 0, 0, 4584, + 4586, 1, 0, 0, 0, 4585, 4587, 3, 44, 22, 0, 4586, 4585, 1, 0, 0, 0, 4586, + 4587, 1, 0, 0, 0, 4587, 4594, 1, 0, 0, 0, 4588, 4589, 5, 187, 0, 0, 4589, + 4590, 5, 1092, 0, 0, 4590, 4591, 5, 1104, 0, 0, 4591, 4592, 3, 428, 214, + 0, 4592, 4593, 5, 1105, 0, 0, 4593, 4595, 1, 0, 0, 0, 4594, 4588, 1, 0, + 0, 0, 4594, 4595, 1, 0, 0, 0, 4595, 4597, 1, 0, 0, 0, 4596, 4598, 3, 646, + 323, 0, 4597, 4596, 1, 0, 0, 0, 4597, 4598, 1, 0, 0, 0, 4598, 4600, 1, + 0, 0, 0, 4599, 4529, 1, 0, 0, 0, 4599, 4539, 1, 0, 0, 0, 4599, 4547, 1, + 0, 0, 0, 4599, 4552, 1, 0, 0, 0, 4599, 4575, 1, 0, 0, 0, 4600, 241, 1, + 0, 0, 0, 4601, 4603, 5, 38, 0, 0, 4602, 4604, 5, 849, 0, 0, 4603, 4602, + 1, 0, 0, 0, 4603, 4604, 1, 0, 0, 0, 4604, 4605, 1, 0, 0, 0, 4605, 4607, + 5, 394, 0, 0, 4606, 4608, 3, 650, 325, 0, 4607, 4606, 1, 0, 0, 0, 4607, + 4608, 1, 0, 0, 0, 4608, 4609, 1, 0, 0, 0, 4609, 4610, 3, 856, 428, 0, 4610, + 4612, 5, 783, 0, 0, 4611, 4613, 3, 466, 233, 0, 4612, 4611, 1, 0, 0, 0, + 4612, 4613, 1, 0, 0, 0, 4613, 4615, 1, 0, 0, 0, 4614, 4616, 3, 138, 69, + 0, 4615, 4614, 1, 0, 0, 0, 4615, 4616, 1, 0, 0, 0, 4616, 4623, 1, 0, 0, + 0, 4617, 4618, 5, 850, 0, 0, 4618, 4619, 5, 1092, 0, 0, 4619, 4620, 5, + 1104, 0, 0, 4620, 4621, 3, 854, 427, 0, 4621, 4622, 5, 1105, 0, 0, 4622, + 4624, 1, 0, 0, 0, 4623, 4617, 1, 0, 0, 0, 4623, 4624, 1, 0, 0, 0, 4624, + 4631, 1, 0, 0, 0, 4625, 4626, 5, 853, 0, 0, 4626, 4627, 5, 1092, 0, 0, + 4627, 4628, 5, 1104, 0, 0, 4628, 4629, 3, 854, 427, 0, 4629, 4630, 5, 1105, + 0, 0, 4630, 4632, 1, 0, 0, 0, 4631, 4625, 1, 0, 0, 0, 4631, 4632, 1, 0, + 0, 0, 4632, 4634, 1, 0, 0, 0, 4633, 4635, 3, 646, 323, 0, 4634, 4633, 1, + 0, 0, 0, 4634, 4635, 1, 0, 0, 0, 4635, 4668, 1, 0, 0, 0, 4636, 4638, 5, + 38, 0, 0, 4637, 4639, 5, 849, 0, 0, 4638, 4637, 1, 0, 0, 0, 4638, 4639, + 1, 0, 0, 0, 4639, 4640, 1, 0, 0, 0, 4640, 4642, 5, 394, 0, 0, 4641, 4643, + 3, 650, 325, 0, 4642, 4641, 1, 0, 0, 0, 4642, 4643, 1, 0, 0, 0, 4643, 4644, + 1, 0, 0, 0, 4644, 4645, 3, 856, 428, 0, 4645, 4646, 3, 300, 150, 0, 4646, + 4668, 1, 0, 0, 0, 4647, 4649, 5, 38, 0, 0, 4648, 4650, 5, 849, 0, 0, 4649, + 4648, 1, 0, 0, 0, 4649, 4650, 1, 0, 0, 0, 4650, 4651, 1, 0, 0, 0, 4651, + 4652, 5, 394, 0, 0, 4652, 4653, 3, 856, 428, 0, 4653, 4654, 3, 304, 152, + 0, 4654, 4668, 1, 0, 0, 0, 4655, 4657, 5, 38, 0, 0, 4656, 4658, 5, 849, + 0, 0, 4657, 4656, 1, 0, 0, 0, 4657, 4658, 1, 0, 0, 0, 4658, 4659, 1, 0, + 0, 0, 4659, 4661, 5, 394, 0, 0, 4660, 4662, 3, 650, 325, 0, 4661, 4660, + 1, 0, 0, 0, 4661, 4662, 1, 0, 0, 0, 4662, 4663, 1, 0, 0, 0, 4663, 4664, + 3, 856, 428, 0, 4664, 4665, 5, 974, 0, 0, 4665, 4666, 7, 29, 0, 0, 4666, + 4668, 1, 0, 0, 0, 4667, 4601, 1, 0, 0, 0, 4667, 4636, 1, 0, 0, 0, 4667, + 4647, 1, 0, 0, 0, 4667, 4655, 1, 0, 0, 0, 4668, 243, 1, 0, 0, 0, 4669, + 4670, 5, 38, 0, 0, 4670, 4672, 5, 857, 0, 0, 4671, 4673, 3, 650, 325, 0, + 4672, 4671, 1, 0, 0, 0, 4672, 4673, 1, 0, 0, 0, 4673, 4674, 1, 0, 0, 0, + 4674, 4675, 3, 856, 428, 0, 4675, 4677, 5, 783, 0, 0, 4676, 4678, 3, 302, + 151, 0, 4677, 4676, 1, 0, 0, 0, 4677, 4678, 1, 0, 0, 0, 4678, 4680, 1, + 0, 0, 0, 4679, 4681, 3, 646, 323, 0, 4680, 4679, 1, 0, 0, 0, 4680, 4681, + 1, 0, 0, 0, 4681, 4705, 1, 0, 0, 0, 4682, 4683, 5, 38, 0, 0, 4683, 4685, + 5, 857, 0, 0, 4684, 4686, 3, 650, 325, 0, 4685, 4684, 1, 0, 0, 0, 4685, + 4686, 1, 0, 0, 0, 4686, 4687, 1, 0, 0, 0, 4687, 4688, 3, 856, 428, 0, 4688, + 4689, 3, 300, 150, 0, 4689, 4705, 1, 0, 0, 0, 4690, 4691, 5, 38, 0, 0, + 4691, 4692, 5, 857, 0, 0, 4692, 4693, 3, 856, 428, 0, 4693, 4694, 3, 304, + 152, 0, 4694, 4705, 1, 0, 0, 0, 4695, 4696, 5, 38, 0, 0, 4696, 4698, 5, + 857, 0, 0, 4697, 4699, 3, 650, 325, 0, 4698, 4697, 1, 0, 0, 0, 4698, 4699, + 1, 0, 0, 0, 4699, 4700, 1, 0, 0, 0, 4700, 4701, 3, 856, 428, 0, 4701, 4702, + 5, 974, 0, 0, 4702, 4703, 5, 161, 0, 0, 4703, 4705, 1, 0, 0, 0, 4704, 4669, + 1, 0, 0, 0, 4704, 4682, 1, 0, 0, 0, 4704, 4690, 1, 0, 0, 0, 4704, 4695, + 1, 0, 0, 0, 4705, 245, 1, 0, 0, 0, 4706, 4707, 5, 38, 0, 0, 4707, 4709, + 5, 880, 0, 0, 4708, 4710, 3, 650, 325, 0, 4709, 4708, 1, 0, 0, 0, 4709, + 4710, 1, 0, 0, 0, 4710, 4711, 1, 0, 0, 0, 4711, 4712, 3, 878, 439, 0, 4712, + 4713, 5, 682, 0, 0, 4713, 4714, 5, 922, 0, 0, 4714, 4715, 3, 878, 439, + 0, 4715, 4882, 1, 0, 0, 0, 4716, 4717, 5, 38, 0, 0, 4717, 4719, 5, 880, + 0, 0, 4718, 4720, 3, 650, 325, 0, 4719, 4718, 1, 0, 0, 0, 4719, 4720, 1, + 0, 0, 0, 4720, 4721, 1, 0, 0, 0, 4721, 4722, 3, 878, 439, 0, 4722, 4723, + 5, 874, 0, 0, 4723, 4724, 5, 1020, 0, 0, 4724, 4725, 3, 878, 439, 0, 4725, + 4882, 1, 0, 0, 0, 4726, 4727, 5, 38, 0, 0, 4727, 4729, 5, 880, 0, 0, 4728, + 4730, 3, 650, 325, 0, 4729, 4728, 1, 0, 0, 0, 4729, 4730, 1, 0, 0, 0, 4730, + 4731, 1, 0, 0, 0, 4731, 4735, 3, 878, 439, 0, 4732, 4736, 3, 248, 124, + 0, 4733, 4736, 3, 250, 125, 0, 4734, 4736, 3, 258, 129, 0, 4735, 4732, + 1, 0, 0, 0, 4735, 4733, 1, 0, 0, 0, 4735, 4734, 1, 0, 0, 0, 4736, 4882, + 1, 0, 0, 0, 4737, 4738, 5, 38, 0, 0, 4738, 4740, 5, 880, 0, 0, 4739, 4741, + 3, 650, 325, 0, 4740, 4739, 1, 0, 0, 0, 4740, 4741, 1, 0, 0, 0, 4741, 4742, + 1, 0, 0, 0, 4742, 4743, 3, 878, 439, 0, 4743, 4744, 3, 256, 128, 0, 4744, + 4882, 1, 0, 0, 0, 4745, 4746, 5, 38, 0, 0, 4746, 4748, 5, 880, 0, 0, 4747, + 4749, 3, 650, 325, 0, 4748, 4747, 1, 0, 0, 0, 4748, 4749, 1, 0, 0, 0, 4749, + 4750, 1, 0, 0, 0, 4750, 4751, 3, 878, 439, 0, 4751, 4752, 3, 260, 130, + 0, 4752, 4882, 1, 0, 0, 0, 4753, 4754, 5, 38, 0, 0, 4754, 4756, 5, 880, + 0, 0, 4755, 4757, 3, 650, 325, 0, 4756, 4755, 1, 0, 0, 0, 4756, 4757, 1, + 0, 0, 0, 4757, 4758, 1, 0, 0, 0, 4758, 4759, 3, 878, 439, 0, 4759, 4761, + 5, 783, 0, 0, 4760, 4762, 3, 50, 25, 0, 4761, 4760, 1, 0, 0, 0, 4761, 4762, + 1, 0, 0, 0, 4762, 4769, 1, 0, 0, 0, 4763, 4764, 5, 824, 0, 0, 4764, 4765, + 5, 1092, 0, 0, 4765, 4766, 5, 1104, 0, 0, 4766, 4767, 3, 428, 214, 0, 4767, + 4768, 5, 1105, 0, 0, 4768, 4770, 1, 0, 0, 0, 4769, 4763, 1, 0, 0, 0, 4769, + 4770, 1, 0, 0, 0, 4770, 4774, 1, 0, 0, 0, 4771, 4772, 5, 209, 0, 0, 4772, + 4773, 5, 1092, 0, 0, 4773, 4775, 3, 880, 440, 0, 4774, 4771, 1, 0, 0, 0, + 4774, 4775, 1, 0, 0, 0, 4775, 4779, 1, 0, 0, 0, 4776, 4777, 5, 467, 0, + 0, 4777, 4778, 5, 1092, 0, 0, 4778, 4780, 3, 880, 440, 0, 4779, 4776, 1, + 0, 0, 0, 4779, 4780, 1, 0, 0, 0, 4780, 4784, 1, 0, 0, 0, 4781, 4782, 5, + 127, 0, 0, 4782, 4783, 5, 1092, 0, 0, 4783, 4785, 3, 450, 225, 0, 4784, + 4781, 1, 0, 0, 0, 4784, 4785, 1, 0, 0, 0, 4785, 4787, 1, 0, 0, 0, 4786, + 4788, 3, 130, 65, 0, 4787, 4786, 1, 0, 0, 0, 4787, 4788, 1, 0, 0, 0, 4788, + 4790, 1, 0, 0, 0, 4789, 4791, 3, 646, 323, 0, 4790, 4789, 1, 0, 0, 0, 4790, + 4791, 1, 0, 0, 0, 4791, 4882, 1, 0, 0, 0, 4792, 4793, 5, 38, 0, 0, 4793, + 4795, 5, 880, 0, 0, 4794, 4796, 3, 650, 325, 0, 4795, 4794, 1, 0, 0, 0, + 4795, 4796, 1, 0, 0, 0, 4796, 4797, 1, 0, 0, 0, 4797, 4798, 3, 878, 439, + 0, 4798, 4799, 3, 300, 150, 0, 4799, 4882, 1, 0, 0, 0, 4800, 4801, 5, 38, + 0, 0, 4801, 4803, 5, 880, 0, 0, 4802, 4804, 3, 650, 325, 0, 4803, 4802, + 1, 0, 0, 0, 4803, 4804, 1, 0, 0, 0, 4804, 4805, 1, 0, 0, 0, 4805, 4806, + 3, 878, 439, 0, 4806, 4807, 3, 304, 152, 0, 4807, 4882, 1, 0, 0, 0, 4808, + 4809, 5, 38, 0, 0, 4809, 4811, 5, 880, 0, 0, 4810, 4812, 3, 650, 325, 0, + 4811, 4810, 1, 0, 0, 0, 4811, 4812, 1, 0, 0, 0, 4812, 4813, 1, 0, 0, 0, + 4813, 4814, 3, 878, 439, 0, 4814, 4821, 5, 974, 0, 0, 4815, 4822, 5, 209, + 0, 0, 4816, 4822, 5, 467, 0, 0, 4817, 4822, 5, 127, 0, 0, 4818, 4822, 5, + 222, 0, 0, 4819, 4822, 5, 161, 0, 0, 4820, 4822, 1, 0, 0, 0, 4821, 4815, + 1, 0, 0, 0, 4821, 4816, 1, 0, 0, 0, 4821, 4817, 1, 0, 0, 0, 4821, 4818, + 1, 0, 0, 0, 4821, 4819, 1, 0, 0, 0, 4821, 4820, 1, 0, 0, 0, 4822, 4882, + 1, 0, 0, 0, 4823, 4824, 5, 38, 0, 0, 4824, 4826, 5, 880, 0, 0, 4825, 4827, + 3, 650, 325, 0, 4826, 4825, 1, 0, 0, 0, 4826, 4827, 1, 0, 0, 0, 4827, 4828, + 1, 0, 0, 0, 4828, 4829, 3, 878, 439, 0, 4829, 4830, 5, 14, 0, 0, 4830, + 4831, 5, 723, 0, 0, 4831, 4832, 5, 8, 0, 0, 4832, 4833, 5, 608, 0, 0, 4833, + 4834, 3, 856, 428, 0, 4834, 4835, 5, 553, 0, 0, 4835, 4836, 3, 368, 184, + 0, 4836, 4882, 1, 0, 0, 0, 4837, 4838, 5, 38, 0, 0, 4838, 4840, 5, 880, + 0, 0, 4839, 4841, 3, 650, 325, 0, 4840, 4839, 1, 0, 0, 0, 4840, 4841, 1, + 0, 0, 0, 4841, 4842, 1, 0, 0, 0, 4842, 4843, 3, 878, 439, 0, 4843, 4844, + 5, 249, 0, 0, 4844, 4845, 5, 723, 0, 0, 4845, 4846, 5, 8, 0, 0, 4846, 4847, + 5, 608, 0, 0, 4847, 4848, 3, 856, 428, 0, 4848, 4882, 1, 0, 0, 0, 4849, + 4850, 5, 38, 0, 0, 4850, 4852, 5, 880, 0, 0, 4851, 4853, 3, 650, 325, 0, + 4852, 4851, 1, 0, 0, 0, 4852, 4853, 1, 0, 0, 0, 4853, 4854, 1, 0, 0, 0, + 4854, 4855, 3, 878, 439, 0, 4855, 4856, 5, 249, 0, 0, 4856, 4857, 5, 723, + 0, 0, 4857, 4858, 5, 8, 0, 0, 4858, 4859, 5, 608, 0, 0, 4859, 4860, 3, + 856, 428, 0, 4860, 4861, 5, 1110, 0, 0, 4861, 4862, 5, 14, 0, 0, 4862, + 4863, 5, 723, 0, 0, 4863, 4864, 5, 8, 0, 0, 4864, 4865, 5, 608, 0, 0, 4865, + 4866, 3, 856, 428, 0, 4866, 4867, 5, 553, 0, 0, 4867, 4868, 3, 368, 184, + 0, 4868, 4882, 1, 0, 0, 0, 4869, 4870, 5, 38, 0, 0, 4870, 4872, 5, 880, + 0, 0, 4871, 4873, 3, 650, 325, 0, 4872, 4871, 1, 0, 0, 0, 4872, 4873, 1, + 0, 0, 0, 4873, 4874, 1, 0, 0, 0, 4874, 4875, 3, 878, 439, 0, 4875, 4876, + 5, 249, 0, 0, 4876, 4877, 5, 23, 0, 0, 4877, 4878, 5, 723, 0, 0, 4878, + 4879, 5, 8, 0, 0, 4879, 4880, 5, 607, 0, 0, 4880, 4882, 1, 0, 0, 0, 4881, + 4706, 1, 0, 0, 0, 4881, 4716, 1, 0, 0, 0, 4881, 4726, 1, 0, 0, 0, 4881, + 4737, 1, 0, 0, 0, 4881, 4745, 1, 0, 0, 0, 4881, 4753, 1, 0, 0, 0, 4881, + 4792, 1, 0, 0, 0, 4881, 4800, 1, 0, 0, 0, 4881, 4808, 1, 0, 0, 0, 4881, + 4823, 1, 0, 0, 0, 4881, 4837, 1, 0, 0, 0, 4881, 4849, 1, 0, 0, 0, 4881, + 4869, 1, 0, 0, 0, 4882, 247, 1, 0, 0, 0, 4883, 4884, 5, 151, 0, 0, 4884, + 4885, 5, 110, 0, 0, 4885, 4886, 5, 1104, 0, 0, 4886, 4887, 3, 882, 441, + 0, 4887, 4888, 5, 1105, 0, 0, 4888, 4906, 1, 0, 0, 0, 4889, 4893, 5, 662, + 0, 0, 4890, 4891, 5, 468, 0, 0, 4891, 4892, 5, 1092, 0, 0, 4892, 4894, + 3, 880, 440, 0, 4893, 4890, 1, 0, 0, 0, 4893, 4894, 1, 0, 0, 0, 4894, 4897, + 1, 0, 0, 0, 4895, 4896, 5, 1019, 0, 0, 4896, 4898, 3, 886, 443, 0, 4897, + 4895, 1, 0, 0, 0, 4897, 4898, 1, 0, 0, 0, 4898, 4906, 1, 0, 0, 0, 4899, + 4900, 3, 142, 71, 0, 4900, 4901, 5, 662, 0, 0, 4901, 4906, 1, 0, 0, 0, + 4902, 4903, 5, 249, 0, 0, 4903, 4904, 5, 153, 0, 0, 4904, 4906, 5, 413, + 0, 0, 4905, 4883, 1, 0, 0, 0, 4905, 4889, 1, 0, 0, 0, 4905, 4899, 1, 0, + 0, 0, 4905, 4902, 1, 0, 0, 0, 4906, 249, 1, 0, 0, 0, 4907, 4909, 5, 14, + 0, 0, 4908, 4910, 5, 157, 0, 0, 4909, 4908, 1, 0, 0, 0, 4909, 4910, 1, + 0, 0, 0, 4910, 4911, 1, 0, 0, 0, 4911, 4912, 3, 874, 437, 0, 4912, 4929, + 3, 902, 451, 0, 4913, 4914, 5, 221, 0, 0, 4914, 4930, 3, 886, 443, 0, 4915, + 4927, 7, 30, 0, 0, 4916, 4917, 5, 1104, 0, 0, 4917, 4918, 3, 880, 440, + 0, 4918, 4919, 5, 1110, 0, 0, 4919, 4920, 3, 880, 440, 0, 4920, 4921, 5, + 1105, 0, 0, 4921, 4928, 1, 0, 0, 0, 4922, 4923, 5, 828, 0, 0, 4923, 4924, + 3, 880, 440, 0, 4924, 4925, 5, 381, 0, 0, 4925, 4926, 3, 880, 440, 0, 4926, + 4928, 1, 0, 0, 0, 4927, 4916, 1, 0, 0, 0, 4927, 4922, 1, 0, 0, 0, 4927, + 4928, 1, 0, 0, 0, 4928, 4930, 1, 0, 0, 0, 4929, 4913, 1, 0, 0, 0, 4929, + 4915, 1, 0, 0, 0, 4929, 4930, 1, 0, 0, 0, 4930, 4932, 1, 0, 0, 0, 4931, + 4933, 3, 1054, 527, 0, 4932, 4931, 1, 0, 0, 0, 4932, 4933, 1, 0, 0, 0, + 4933, 4935, 1, 0, 0, 0, 4934, 4936, 3, 252, 126, 0, 4935, 4934, 1, 0, 0, + 0, 4935, 4936, 1, 0, 0, 0, 4936, 4952, 1, 0, 0, 0, 4937, 4939, 5, 1020, + 0, 0, 4938, 4937, 1, 0, 0, 0, 4938, 4939, 1, 0, 0, 0, 4939, 4940, 1, 0, + 0, 0, 4940, 4941, 5, 455, 0, 0, 4941, 4942, 5, 608, 0, 0, 4942, 4950, 3, + 856, 428, 0, 4943, 4944, 5, 992, 0, 0, 4944, 4945, 5, 1104, 0, 0, 4945, + 4946, 3, 874, 437, 0, 4946, 4947, 5, 1110, 0, 0, 4947, 4948, 3, 876, 438, + 0, 4948, 4949, 5, 1105, 0, 0, 4949, 4951, 1, 0, 0, 0, 4950, 4943, 1, 0, + 0, 0, 4950, 4951, 1, 0, 0, 0, 4951, 4953, 1, 0, 0, 0, 4952, 4938, 1, 0, + 0, 0, 4952, 4953, 1, 0, 0, 0, 4953, 5074, 1, 0, 0, 0, 4954, 4955, 5, 682, + 0, 0, 4955, 4956, 5, 157, 0, 0, 4956, 4957, 3, 874, 437, 0, 4957, 4958, + 5, 922, 0, 0, 4958, 4959, 3, 874, 437, 0, 4959, 5074, 1, 0, 0, 0, 4960, + 4962, 3, 284, 142, 0, 4961, 4963, 5, 1104, 0, 0, 4962, 4961, 1, 0, 0, 0, + 4962, 4963, 1, 0, 0, 0, 4963, 4965, 1, 0, 0, 0, 4964, 4966, 5, 157, 0, + 0, 4965, 4964, 1, 0, 0, 0, 4965, 4966, 1, 0, 0, 0, 4966, 4967, 1, 0, 0, + 0, 4967, 4968, 3, 874, 437, 0, 4968, 4969, 5, 249, 0, 0, 4969, 4970, 5, + 221, 0, 0, 4970, 4972, 5, 1110, 0, 0, 4971, 4973, 5, 157, 0, 0, 4972, 4971, + 1, 0, 0, 0, 4972, 4973, 1, 0, 0, 0, 4973, 4974, 1, 0, 0, 0, 4974, 4975, + 3, 874, 437, 0, 4975, 4976, 5, 783, 0, 0, 4976, 4977, 5, 221, 0, 0, 4977, + 4978, 3, 878, 439, 0, 4978, 4979, 5, 1099, 0, 0, 4979, 4980, 5, 506, 0, + 0, 4980, 4982, 5, 1110, 0, 0, 4981, 4983, 5, 157, 0, 0, 4982, 4981, 1, + 0, 0, 0, 4982, 4983, 1, 0, 0, 0, 4983, 4984, 1, 0, 0, 0, 4984, 4993, 3, + 874, 437, 0, 4985, 4987, 5, 783, 0, 0, 4986, 4985, 1, 0, 0, 0, 4986, 4987, + 1, 0, 0, 0, 4987, 4988, 1, 0, 0, 0, 4988, 4989, 5, 511, 0, 0, 4989, 4994, + 5, 522, 0, 0, 4990, 4991, 5, 249, 0, 0, 4991, 4992, 5, 511, 0, 0, 4992, + 4994, 5, 522, 0, 0, 4993, 4986, 1, 0, 0, 0, 4993, 4990, 1, 0, 0, 0, 4994, + 4995, 1, 0, 0, 0, 4995, 4997, 5, 1110, 0, 0, 4996, 4998, 5, 157, 0, 0, + 4997, 4996, 1, 0, 0, 0, 4997, 4998, 1, 0, 0, 0, 4998, 4999, 1, 0, 0, 0, + 4999, 5005, 3, 874, 437, 0, 5000, 5001, 5, 783, 0, 0, 5001, 5003, 5, 206, + 0, 0, 5002, 5000, 1, 0, 0, 0, 5002, 5003, 1, 0, 0, 0, 5003, 5004, 1, 0, + 0, 0, 5004, 5006, 5, 954, 0, 0, 5005, 5002, 1, 0, 0, 0, 5005, 5006, 1, + 0, 0, 0, 5006, 5007, 1, 0, 0, 0, 5007, 5008, 3, 902, 451, 0, 5008, 5010, + 5, 1110, 0, 0, 5009, 5011, 5, 157, 0, 0, 5010, 5009, 1, 0, 0, 0, 5010, + 5011, 1, 0, 0, 0, 5011, 5012, 1, 0, 0, 0, 5012, 5013, 3, 874, 437, 0, 5013, + 5014, 3, 646, 323, 0, 5014, 5016, 5, 1110, 0, 0, 5015, 5017, 5, 157, 0, + 0, 5016, 5015, 1, 0, 0, 0, 5016, 5017, 1, 0, 0, 0, 5017, 5018, 1, 0, 0, + 0, 5018, 5019, 3, 874, 437, 0, 5019, 5020, 5, 974, 0, 0, 5020, 5022, 5, + 161, 0, 0, 5021, 5023, 5, 1105, 0, 0, 5022, 5021, 1, 0, 0, 0, 5022, 5023, + 1, 0, 0, 0, 5023, 5074, 1, 0, 0, 0, 5024, 5025, 3, 284, 142, 0, 5025, 5026, + 5, 157, 0, 0, 5026, 5027, 3, 874, 437, 0, 5027, 5028, 5, 783, 0, 0, 5028, + 5029, 5, 455, 0, 0, 5029, 5030, 5, 608, 0, 0, 5030, 5038, 3, 856, 428, + 0, 5031, 5032, 5, 992, 0, 0, 5032, 5033, 5, 1104, 0, 0, 5033, 5034, 3, + 874, 437, 0, 5034, 5035, 5, 1110, 0, 0, 5035, 5036, 3, 876, 438, 0, 5036, + 5037, 5, 1105, 0, 0, 5037, 5039, 1, 0, 0, 0, 5038, 5031, 1, 0, 0, 0, 5038, + 5039, 1, 0, 0, 0, 5039, 5041, 1, 0, 0, 0, 5040, 5042, 5, 323, 0, 0, 5041, + 5040, 1, 0, 0, 0, 5041, 5042, 1, 0, 0, 0, 5042, 5074, 1, 0, 0, 0, 5043, + 5044, 3, 284, 142, 0, 5044, 5045, 5, 157, 0, 0, 5045, 5046, 3, 874, 437, + 0, 5046, 5047, 5, 974, 0, 0, 5047, 5048, 5, 455, 0, 0, 5048, 5049, 5, 608, + 0, 0, 5049, 5074, 1, 0, 0, 0, 5050, 5051, 3, 284, 142, 0, 5051, 5056, 3, + 272, 136, 0, 5052, 5053, 5, 1110, 0, 0, 5053, 5055, 3, 272, 136, 0, 5054, + 5052, 1, 0, 0, 0, 5055, 5058, 1, 0, 0, 0, 5056, 5054, 1, 0, 0, 0, 5056, + 5057, 1, 0, 0, 0, 5057, 5074, 1, 0, 0, 0, 5058, 5056, 1, 0, 0, 0, 5059, + 5060, 3, 284, 142, 0, 5060, 5065, 3, 274, 137, 0, 5061, 5062, 5, 1110, + 0, 0, 5062, 5064, 3, 274, 137, 0, 5063, 5061, 1, 0, 0, 0, 5064, 5067, 1, + 0, 0, 0, 5065, 5063, 1, 0, 0, 0, 5065, 5066, 1, 0, 0, 0, 5066, 5074, 1, + 0, 0, 0, 5067, 5065, 1, 0, 0, 0, 5068, 5070, 5, 249, 0, 0, 5069, 5071, + 5, 157, 0, 0, 5070, 5069, 1, 0, 0, 0, 5070, 5071, 1, 0, 0, 0, 5071, 5072, + 1, 0, 0, 0, 5072, 5074, 3, 876, 438, 0, 5073, 4907, 1, 0, 0, 0, 5073, 4954, + 1, 0, 0, 0, 5073, 4960, 1, 0, 0, 0, 5073, 5024, 1, 0, 0, 0, 5073, 5043, + 1, 0, 0, 0, 5073, 5050, 1, 0, 0, 0, 5073, 5059, 1, 0, 0, 0, 5073, 5068, + 1, 0, 0, 0, 5074, 251, 1, 0, 0, 0, 5075, 5077, 3, 1054, 527, 0, 5076, 5075, + 1, 0, 0, 0, 5076, 5077, 1, 0, 0, 0, 5077, 5080, 1, 0, 0, 0, 5078, 5079, + 5, 174, 0, 0, 5079, 5081, 3, 856, 428, 0, 5080, 5078, 1, 0, 0, 0, 5080, + 5081, 1, 0, 0, 0, 5081, 5097, 1, 0, 0, 0, 5082, 5098, 5, 966, 0, 0, 5083, + 5084, 5, 619, 0, 0, 5084, 5098, 5, 413, 0, 0, 5085, 5086, 5, 324, 0, 0, + 5086, 5088, 5, 413, 0, 0, 5087, 5085, 1, 0, 0, 0, 5087, 5088, 1, 0, 0, + 0, 5088, 5089, 1, 0, 0, 0, 5089, 5090, 5, 669, 0, 0, 5090, 5095, 3, 878, + 439, 0, 5091, 5092, 5, 1104, 0, 0, 5092, 5093, 3, 874, 437, 0, 5093, 5094, + 5, 1105, 0, 0, 5094, 5096, 1, 0, 0, 0, 5095, 5091, 1, 0, 0, 0, 5095, 5096, + 1, 0, 0, 0, 5096, 5098, 1, 0, 0, 0, 5097, 5082, 1, 0, 0, 0, 5097, 5083, + 1, 0, 0, 0, 5097, 5087, 1, 0, 0, 0, 5098, 5100, 1, 0, 0, 0, 5099, 5101, + 3, 254, 127, 0, 5100, 5099, 1, 0, 0, 0, 5100, 5101, 1, 0, 0, 0, 5101, 253, + 1, 0, 0, 0, 5102, 5104, 5, 511, 0, 0, 5103, 5102, 1, 0, 0, 0, 5103, 5104, + 1, 0, 0, 0, 5104, 5105, 1, 0, 0, 0, 5105, 5143, 5, 269, 0, 0, 5106, 5108, + 5, 511, 0, 0, 5107, 5106, 1, 0, 0, 0, 5107, 5108, 1, 0, 0, 0, 5108, 5109, + 1, 0, 0, 0, 5109, 5143, 5, 226, 0, 0, 5110, 5111, 5, 385, 0, 0, 5111, 5143, + 7, 31, 0, 0, 5112, 5113, 5, 458, 0, 0, 5113, 5143, 7, 32, 0, 0, 5114, 5123, + 5, 977, 0, 0, 5115, 5124, 5, 116, 0, 0, 5116, 5117, 5, 783, 0, 0, 5117, + 5124, 5, 522, 0, 0, 5118, 5119, 5, 783, 0, 0, 5119, 5124, 5, 221, 0, 0, + 5120, 5124, 5, 700, 0, 0, 5121, 5122, 5, 507, 0, 0, 5122, 5124, 5, 12, + 0, 0, 5123, 5115, 1, 0, 0, 0, 5123, 5116, 1, 0, 0, 0, 5123, 5118, 1, 0, + 0, 0, 5123, 5120, 1, 0, 0, 0, 5123, 5121, 1, 0, 0, 0, 5124, 5143, 1, 0, + 0, 0, 5125, 5134, 5, 232, 0, 0, 5126, 5135, 5, 116, 0, 0, 5127, 5128, 5, + 783, 0, 0, 5128, 5135, 5, 522, 0, 0, 5129, 5130, 5, 783, 0, 0, 5130, 5135, + 5, 221, 0, 0, 5131, 5135, 5, 700, 0, 0, 5132, 5133, 5, 507, 0, 0, 5133, + 5135, 5, 12, 0, 0, 5134, 5126, 1, 0, 0, 0, 5134, 5127, 1, 0, 0, 0, 5134, + 5129, 1, 0, 0, 0, 5134, 5131, 1, 0, 0, 0, 5134, 5132, 1, 0, 0, 0, 5135, + 5143, 1, 0, 0, 0, 5136, 5143, 5, 257, 0, 0, 5137, 5143, 5, 239, 0, 0, 5138, + 5143, 5, 994, 0, 0, 5139, 5143, 5, 518, 0, 0, 5140, 5143, 5, 677, 0, 0, + 5141, 5143, 5, 510, 0, 0, 5142, 5103, 1, 0, 0, 0, 5142, 5107, 1, 0, 0, + 0, 5142, 5110, 1, 0, 0, 0, 5142, 5112, 1, 0, 0, 0, 5142, 5114, 1, 0, 0, + 0, 5142, 5125, 1, 0, 0, 0, 5142, 5136, 1, 0, 0, 0, 5142, 5137, 1, 0, 0, + 0, 5142, 5138, 1, 0, 0, 0, 5142, 5139, 1, 0, 0, 0, 5142, 5140, 1, 0, 0, + 0, 5142, 5141, 1, 0, 0, 0, 5143, 255, 1, 0, 0, 0, 5144, 5146, 5, 14, 0, + 0, 5145, 5147, 5, 157, 0, 0, 5146, 5145, 1, 0, 0, 0, 5146, 5147, 1, 0, + 0, 0, 5147, 5148, 1, 0, 0, 0, 5148, 5149, 3, 874, 437, 0, 5149, 5150, 3, + 902, 451, 0, 5150, 5151, 5, 56, 0, 0, 5151, 5152, 5, 1104, 0, 0, 5152, + 5153, 3, 886, 443, 0, 5153, 5154, 5, 1105, 0, 0, 5154, 5167, 1, 0, 0, 0, + 5155, 5156, 5, 682, 0, 0, 5156, 5157, 5, 157, 0, 0, 5157, 5158, 3, 874, + 437, 0, 5158, 5159, 5, 922, 0, 0, 5159, 5160, 3, 874, 437, 0, 5160, 5167, + 1, 0, 0, 0, 5161, 5163, 5, 249, 0, 0, 5162, 5164, 5, 157, 0, 0, 5163, 5162, + 1, 0, 0, 0, 5163, 5164, 1, 0, 0, 0, 5164, 5165, 1, 0, 0, 0, 5165, 5167, + 3, 876, 438, 0, 5166, 5144, 1, 0, 0, 0, 5166, 5155, 1, 0, 0, 0, 5166, 5161, + 1, 0, 0, 0, 5167, 257, 1, 0, 0, 0, 5168, 5169, 5, 14, 0, 0, 5169, 5211, + 3, 506, 253, 0, 5170, 5171, 5, 682, 0, 0, 5171, 5172, 5, 174, 0, 0, 5172, + 5173, 3, 856, 428, 0, 5173, 5174, 5, 922, 0, 0, 5174, 5175, 3, 856, 428, + 0, 5175, 5211, 1, 0, 0, 0, 5176, 5184, 3, 284, 142, 0, 5177, 5178, 5, 174, + 0, 0, 5178, 5185, 3, 856, 428, 0, 5179, 5180, 5, 619, 0, 0, 5180, 5185, + 5, 413, 0, 0, 5181, 5185, 5, 966, 0, 0, 5182, 5183, 5, 324, 0, 0, 5183, + 5185, 5, 413, 0, 0, 5184, 5177, 1, 0, 0, 0, 5184, 5179, 1, 0, 0, 0, 5184, + 5181, 1, 0, 0, 0, 5184, 5182, 1, 0, 0, 0, 5185, 5186, 1, 0, 0, 0, 5186, + 5191, 3, 368, 184, 0, 5187, 5189, 5, 511, 0, 0, 5188, 5187, 1, 0, 0, 0, + 5188, 5189, 1, 0, 0, 0, 5189, 5190, 1, 0, 0, 0, 5190, 5192, 5, 269, 0, + 0, 5191, 5188, 1, 0, 0, 0, 5191, 5192, 1, 0, 0, 0, 5192, 5193, 1, 0, 0, + 0, 5193, 5194, 7, 33, 0, 0, 5194, 5195, 7, 34, 0, 0, 5195, 5211, 1, 0, + 0, 0, 5196, 5204, 5, 249, 0, 0, 5197, 5198, 5, 174, 0, 0, 5198, 5205, 3, + 856, 428, 0, 5199, 5200, 5, 619, 0, 0, 5200, 5205, 5, 413, 0, 0, 5201, + 5205, 5, 966, 0, 0, 5202, 5203, 5, 324, 0, 0, 5203, 5205, 5, 413, 0, 0, + 5204, 5197, 1, 0, 0, 0, 5204, 5199, 1, 0, 0, 0, 5204, 5201, 1, 0, 0, 0, + 5204, 5202, 1, 0, 0, 0, 5205, 5206, 1, 0, 0, 0, 5206, 5208, 3, 368, 184, + 0, 5207, 5209, 3, 618, 309, 0, 5208, 5207, 1, 0, 0, 0, 5208, 5209, 1, 0, + 0, 0, 5209, 5211, 1, 0, 0, 0, 5210, 5168, 1, 0, 0, 0, 5210, 5170, 1, 0, + 0, 0, 5210, 5176, 1, 0, 0, 0, 5210, 5196, 1, 0, 0, 0, 5211, 259, 1, 0, + 0, 0, 5212, 5213, 5, 14, 0, 0, 5213, 5214, 5, 763, 0, 0, 5214, 5224, 5, + 562, 0, 0, 5215, 5216, 5, 553, 0, 0, 5216, 5221, 3, 262, 131, 0, 5217, + 5218, 5, 1110, 0, 0, 5218, 5220, 3, 262, 131, 0, 5219, 5217, 1, 0, 0, 0, + 5220, 5223, 1, 0, 0, 0, 5221, 5219, 1, 0, 0, 0, 5221, 5222, 1, 0, 0, 0, + 5222, 5225, 1, 0, 0, 0, 5223, 5221, 1, 0, 0, 0, 5224, 5215, 1, 0, 0, 0, + 5224, 5225, 1, 0, 0, 0, 5225, 5241, 1, 0, 0, 0, 5226, 5227, 5, 249, 0, + 0, 5227, 5228, 5, 763, 0, 0, 5228, 5238, 5, 562, 0, 0, 5229, 5230, 5, 553, + 0, 0, 5230, 5235, 3, 262, 131, 0, 5231, 5232, 5, 1110, 0, 0, 5232, 5234, + 3, 262, 131, 0, 5233, 5231, 1, 0, 0, 0, 5234, 5237, 1, 0, 0, 0, 5235, 5233, + 1, 0, 0, 0, 5235, 5236, 1, 0, 0, 0, 5236, 5239, 1, 0, 0, 0, 5237, 5235, + 1, 0, 0, 0, 5238, 5229, 1, 0, 0, 0, 5238, 5239, 1, 0, 0, 0, 5239, 5241, + 1, 0, 0, 0, 5240, 5212, 1, 0, 0, 0, 5240, 5226, 1, 0, 0, 0, 5241, 261, + 1, 0, 0, 0, 5242, 5243, 7, 35, 0, 0, 5243, 5246, 5, 1104, 0, 0, 5244, 5247, + 5, 1114, 0, 0, 5245, 5247, 3, 886, 443, 0, 5246, 5244, 1, 0, 0, 0, 5246, + 5245, 1, 0, 0, 0, 5247, 5248, 1, 0, 0, 0, 5248, 5249, 5, 1105, 0, 0, 5249, + 263, 1, 0, 0, 0, 5250, 5251, 5, 38, 0, 0, 5251, 5252, 5, 880, 0, 0, 5252, + 5253, 3, 878, 439, 0, 5253, 5259, 3, 284, 142, 0, 5254, 5255, 5, 1104, + 0, 0, 5255, 5256, 3, 266, 133, 0, 5256, 5257, 5, 1105, 0, 0, 5257, 5260, + 1, 0, 0, 0, 5258, 5260, 3, 266, 133, 0, 5259, 5254, 1, 0, 0, 0, 5259, 5258, + 1, 0, 0, 0, 5260, 5318, 1, 0, 0, 0, 5261, 5262, 5, 38, 0, 0, 5262, 5263, + 5, 880, 0, 0, 5263, 5264, 3, 878, 439, 0, 5264, 5265, 3, 284, 142, 0, 5265, + 5266, 5, 157, 0, 0, 5266, 5267, 3, 874, 437, 0, 5267, 5268, 5, 783, 0, + 0, 5268, 5269, 5, 455, 0, 0, 5269, 5270, 5, 608, 0, 0, 5270, 5278, 3, 856, + 428, 0, 5271, 5272, 5, 992, 0, 0, 5272, 5273, 5, 1104, 0, 0, 5273, 5274, + 3, 874, 437, 0, 5274, 5275, 5, 1110, 0, 0, 5275, 5276, 3, 876, 438, 0, + 5276, 5277, 5, 1105, 0, 0, 5277, 5279, 1, 0, 0, 0, 5278, 5271, 1, 0, 0, + 0, 5278, 5279, 1, 0, 0, 0, 5279, 5281, 1, 0, 0, 0, 5280, 5282, 5, 323, + 0, 0, 5281, 5280, 1, 0, 0, 0, 5281, 5282, 1, 0, 0, 0, 5282, 5318, 1, 0, + 0, 0, 5283, 5284, 5, 38, 0, 0, 5284, 5285, 5, 880, 0, 0, 5285, 5286, 3, + 878, 439, 0, 5286, 5287, 3, 284, 142, 0, 5287, 5288, 5, 157, 0, 0, 5288, + 5289, 3, 874, 437, 0, 5289, 5290, 5, 974, 0, 0, 5290, 5291, 5, 455, 0, + 0, 5291, 5292, 5, 608, 0, 0, 5292, 5318, 1, 0, 0, 0, 5293, 5294, 5, 38, + 0, 0, 5294, 5295, 5, 880, 0, 0, 5295, 5296, 3, 878, 439, 0, 5296, 5297, + 3, 284, 142, 0, 5297, 5302, 3, 272, 136, 0, 5298, 5299, 5, 1110, 0, 0, + 5299, 5301, 3, 272, 136, 0, 5300, 5298, 1, 0, 0, 0, 5301, 5304, 1, 0, 0, + 0, 5302, 5300, 1, 0, 0, 0, 5302, 5303, 1, 0, 0, 0, 5303, 5318, 1, 0, 0, + 0, 5304, 5302, 1, 0, 0, 0, 5305, 5306, 5, 38, 0, 0, 5306, 5307, 5, 880, + 0, 0, 5307, 5308, 3, 878, 439, 0, 5308, 5309, 3, 284, 142, 0, 5309, 5314, + 3, 274, 137, 0, 5310, 5311, 5, 1110, 0, 0, 5311, 5313, 3, 274, 137, 0, + 5312, 5310, 1, 0, 0, 0, 5313, 5316, 1, 0, 0, 0, 5314, 5312, 1, 0, 0, 0, + 5314, 5315, 1, 0, 0, 0, 5315, 5318, 1, 0, 0, 0, 5316, 5314, 1, 0, 0, 0, + 5317, 5250, 1, 0, 0, 0, 5317, 5261, 1, 0, 0, 0, 5317, 5283, 1, 0, 0, 0, + 5317, 5293, 1, 0, 0, 0, 5317, 5305, 1, 0, 0, 0, 5318, 265, 1, 0, 0, 0, + 5319, 5324, 3, 268, 134, 0, 5320, 5321, 5, 1110, 0, 0, 5321, 5323, 3, 268, + 134, 0, 5322, 5320, 1, 0, 0, 0, 5323, 5326, 1, 0, 0, 0, 5324, 5322, 1, + 0, 0, 0, 5324, 5325, 1, 0, 0, 0, 5325, 267, 1, 0, 0, 0, 5326, 5324, 1, + 0, 0, 0, 5327, 5329, 5, 157, 0, 0, 5328, 5327, 1, 0, 0, 0, 5328, 5329, + 1, 0, 0, 0, 5329, 5330, 1, 0, 0, 0, 5330, 5331, 3, 874, 437, 0, 5331, 5332, + 3, 270, 135, 0, 5332, 269, 1, 0, 0, 0, 5333, 5334, 5, 249, 0, 0, 5334, + 5363, 5, 221, 0, 0, 5335, 5336, 5, 783, 0, 0, 5336, 5337, 5, 221, 0, 0, + 5337, 5338, 3, 878, 439, 0, 5338, 5339, 5, 1099, 0, 0, 5339, 5340, 5, 506, + 0, 0, 5340, 5363, 1, 0, 0, 0, 5341, 5343, 5, 783, 0, 0, 5342, 5341, 1, + 0, 0, 0, 5342, 5343, 1, 0, 0, 0, 5343, 5344, 1, 0, 0, 0, 5344, 5345, 5, + 511, 0, 0, 5345, 5350, 5, 522, 0, 0, 5346, 5347, 5, 249, 0, 0, 5347, 5348, + 5, 511, 0, 0, 5348, 5350, 5, 522, 0, 0, 5349, 5342, 1, 0, 0, 0, 5349, 5346, + 1, 0, 0, 0, 5350, 5363, 1, 0, 0, 0, 5351, 5352, 5, 783, 0, 0, 5352, 5354, + 5, 206, 0, 0, 5353, 5351, 1, 0, 0, 0, 5353, 5354, 1, 0, 0, 0, 5354, 5355, + 1, 0, 0, 0, 5355, 5357, 5, 954, 0, 0, 5356, 5353, 1, 0, 0, 0, 5356, 5357, + 1, 0, 0, 0, 5357, 5358, 1, 0, 0, 0, 5358, 5363, 3, 902, 451, 0, 5359, 5363, + 3, 646, 323, 0, 5360, 5361, 5, 974, 0, 0, 5361, 5363, 5, 161, 0, 0, 5362, + 5333, 1, 0, 0, 0, 5362, 5335, 1, 0, 0, 0, 5362, 5349, 1, 0, 0, 0, 5362, + 5356, 1, 0, 0, 0, 5362, 5359, 1, 0, 0, 0, 5362, 5360, 1, 0, 0, 0, 5363, + 271, 1, 0, 0, 0, 5364, 5366, 5, 157, 0, 0, 5365, 5364, 1, 0, 0, 0, 5365, + 5366, 1, 0, 0, 0, 5366, 5367, 1, 0, 0, 0, 5367, 5368, 3, 874, 437, 0, 5368, + 5369, 3, 300, 150, 0, 5369, 273, 1, 0, 0, 0, 5370, 5371, 5, 157, 0, 0, + 5371, 5372, 3, 874, 437, 0, 5372, 5373, 3, 304, 152, 0, 5373, 275, 1, 0, + 0, 0, 5374, 5375, 5, 38, 0, 0, 5375, 5376, 5, 887, 0, 0, 5376, 5377, 3, + 292, 146, 0, 5377, 277, 1, 0, 0, 0, 5378, 5379, 5, 38, 0, 0, 5379, 5381, + 5, 891, 0, 0, 5380, 5382, 3, 650, 325, 0, 5381, 5380, 1, 0, 0, 0, 5381, + 5382, 1, 0, 0, 0, 5382, 5383, 1, 0, 0, 0, 5383, 5384, 3, 856, 428, 0, 5384, + 5385, 3, 142, 71, 0, 5385, 5502, 1, 0, 0, 0, 5386, 5387, 5, 38, 0, 0, 5387, + 5389, 5, 891, 0, 0, 5388, 5390, 3, 650, 325, 0, 5389, 5388, 1, 0, 0, 0, + 5389, 5390, 1, 0, 0, 0, 5390, 5391, 1, 0, 0, 0, 5391, 5392, 3, 856, 428, + 0, 5392, 5393, 5, 681, 0, 0, 5393, 5394, 5, 19, 0, 0, 5394, 5395, 3, 854, + 427, 0, 5395, 5502, 1, 0, 0, 0, 5396, 5397, 5, 14, 0, 0, 5397, 5398, 5, + 19, 0, 0, 5398, 5502, 3, 854, 427, 0, 5399, 5400, 5, 38, 0, 0, 5400, 5402, + 5, 891, 0, 0, 5401, 5403, 3, 650, 325, 0, 5402, 5401, 1, 0, 0, 0, 5402, + 5403, 1, 0, 0, 0, 5403, 5404, 1, 0, 0, 0, 5404, 5405, 3, 856, 428, 0, 5405, + 5409, 5, 783, 0, 0, 5406, 5407, 5, 1011, 0, 0, 5407, 5408, 5, 1092, 0, + 0, 5408, 5410, 3, 852, 426, 0, 5409, 5406, 1, 0, 0, 0, 5409, 5410, 1, 0, + 0, 0, 5410, 5414, 1, 0, 0, 0, 5411, 5412, 5, 755, 0, 0, 5412, 5413, 5, + 1092, 0, 0, 5413, 5415, 3, 852, 426, 0, 5414, 5411, 1, 0, 0, 0, 5414, 5415, + 1, 0, 0, 0, 5415, 5419, 1, 0, 0, 0, 5416, 5417, 5, 36, 0, 0, 5417, 5418, + 5, 1092, 0, 0, 5418, 5420, 3, 450, 225, 0, 5419, 5416, 1, 0, 0, 0, 5419, + 5420, 1, 0, 0, 0, 5420, 5424, 1, 0, 0, 0, 5421, 5422, 5, 989, 0, 0, 5422, + 5423, 5, 1092, 0, 0, 5423, 5425, 3, 880, 440, 0, 5424, 5421, 1, 0, 0, 0, + 5424, 5425, 1, 0, 0, 0, 5425, 5429, 1, 0, 0, 0, 5426, 5427, 5, 873, 0, + 0, 5427, 5428, 5, 1092, 0, 0, 5428, 5430, 3, 880, 440, 0, 5429, 5426, 1, + 0, 0, 0, 5429, 5430, 1, 0, 0, 0, 5430, 5432, 1, 0, 0, 0, 5431, 5433, 3, + 646, 323, 0, 5432, 5431, 1, 0, 0, 0, 5432, 5433, 1, 0, 0, 0, 5433, 5435, + 1, 0, 0, 0, 5434, 5436, 3, 524, 262, 0, 5435, 5434, 1, 0, 0, 0, 5435, 5436, + 1, 0, 0, 0, 5436, 5502, 1, 0, 0, 0, 5437, 5438, 5, 38, 0, 0, 5438, 5440, + 5, 891, 0, 0, 5439, 5441, 3, 650, 325, 0, 5440, 5439, 1, 0, 0, 0, 5440, + 5441, 1, 0, 0, 0, 5441, 5442, 1, 0, 0, 0, 5442, 5443, 3, 856, 428, 0, 5443, + 5445, 5, 974, 0, 0, 5444, 5446, 5, 1011, 0, 0, 5445, 5444, 1, 0, 0, 0, + 5445, 5446, 1, 0, 0, 0, 5446, 5448, 1, 0, 0, 0, 5447, 5449, 5, 755, 0, + 0, 5448, 5447, 1, 0, 0, 0, 5448, 5449, 1, 0, 0, 0, 5449, 5451, 1, 0, 0, + 0, 5450, 5452, 5, 36, 0, 0, 5451, 5450, 1, 0, 0, 0, 5451, 5452, 1, 0, 0, + 0, 5452, 5454, 1, 0, 0, 0, 5453, 5455, 5, 989, 0, 0, 5454, 5453, 1, 0, + 0, 0, 5454, 5455, 1, 0, 0, 0, 5455, 5457, 1, 0, 0, 0, 5456, 5458, 5, 873, + 0, 0, 5457, 5456, 1, 0, 0, 0, 5457, 5458, 1, 0, 0, 0, 5458, 5460, 1, 0, + 0, 0, 5459, 5461, 5, 161, 0, 0, 5460, 5459, 1, 0, 0, 0, 5460, 5461, 1, + 0, 0, 0, 5461, 5463, 1, 0, 0, 0, 5462, 5464, 3, 522, 261, 0, 5463, 5462, + 1, 0, 0, 0, 5463, 5464, 1, 0, 0, 0, 5464, 5502, 1, 0, 0, 0, 5465, 5466, + 5, 38, 0, 0, 5466, 5468, 5, 891, 0, 0, 5467, 5469, 3, 650, 325, 0, 5468, + 5467, 1, 0, 0, 0, 5468, 5469, 1, 0, 0, 0, 5469, 5470, 1, 0, 0, 0, 5470, + 5471, 3, 856, 428, 0, 5471, 5472, 3, 300, 150, 0, 5472, 5502, 1, 0, 0, + 0, 5473, 5474, 5, 38, 0, 0, 5474, 5476, 5, 891, 0, 0, 5475, 5477, 3, 650, + 325, 0, 5476, 5475, 1, 0, 0, 0, 5476, 5477, 1, 0, 0, 0, 5477, 5478, 1, + 0, 0, 0, 5478, 5479, 3, 856, 428, 0, 5479, 5480, 3, 304, 152, 0, 5480, + 5502, 1, 0, 0, 0, 5481, 5482, 5, 38, 0, 0, 5482, 5484, 5, 891, 0, 0, 5483, + 5485, 3, 650, 325, 0, 5484, 5483, 1, 0, 0, 0, 5484, 5485, 1, 0, 0, 0, 5485, + 5486, 1, 0, 0, 0, 5486, 5487, 3, 856, 428, 0, 5487, 5488, 5, 483, 0, 0, + 5488, 5489, 5, 56, 0, 0, 5489, 5490, 3, 530, 265, 0, 5490, 5502, 1, 0, + 0, 0, 5491, 5492, 5, 38, 0, 0, 5492, 5494, 5, 891, 0, 0, 5493, 5495, 3, + 650, 325, 0, 5494, 5493, 1, 0, 0, 0, 5494, 5495, 1, 0, 0, 0, 5495, 5496, + 1, 0, 0, 0, 5496, 5497, 3, 856, 428, 0, 5497, 5498, 5, 483, 0, 0, 5498, + 5499, 5, 1018, 0, 0, 5499, 5500, 3, 886, 443, 0, 5500, 5502, 1, 0, 0, 0, + 5501, 5378, 1, 0, 0, 0, 5501, 5386, 1, 0, 0, 0, 5501, 5396, 1, 0, 0, 0, + 5501, 5399, 1, 0, 0, 0, 5501, 5437, 1, 0, 0, 0, 5501, 5465, 1, 0, 0, 0, + 5501, 5473, 1, 0, 0, 0, 5501, 5481, 1, 0, 0, 0, 5501, 5491, 1, 0, 0, 0, + 5502, 279, 1, 0, 0, 0, 5503, 5504, 5, 38, 0, 0, 5504, 5506, 5, 984, 0, + 0, 5505, 5507, 3, 650, 325, 0, 5506, 5505, 1, 0, 0, 0, 5506, 5507, 1, 0, + 0, 0, 5507, 5508, 1, 0, 0, 0, 5508, 5509, 3, 856, 428, 0, 5509, 5510, 3, + 290, 145, 0, 5510, 281, 1, 0, 0, 0, 5511, 5512, 5, 38, 0, 0, 5512, 5514, + 5, 1005, 0, 0, 5513, 5515, 3, 650, 325, 0, 5514, 5513, 1, 0, 0, 0, 5514, + 5515, 1, 0, 0, 0, 5515, 5516, 1, 0, 0, 0, 5516, 5517, 3, 856, 428, 0, 5517, + 5518, 5, 682, 0, 0, 5518, 5519, 5, 922, 0, 0, 5519, 5520, 3, 856, 428, + 0, 5520, 5680, 1, 0, 0, 0, 5521, 5522, 5, 38, 0, 0, 5522, 5524, 5, 1005, + 0, 0, 5523, 5525, 3, 650, 325, 0, 5524, 5523, 1, 0, 0, 0, 5524, 5525, 1, + 0, 0, 0, 5525, 5526, 1, 0, 0, 0, 5526, 5527, 3, 856, 428, 0, 5527, 5528, + 5, 783, 0, 0, 5528, 5529, 3, 646, 323, 0, 5529, 5680, 1, 0, 0, 0, 5530, + 5531, 5, 38, 0, 0, 5531, 5533, 5, 1005, 0, 0, 5532, 5534, 3, 650, 325, + 0, 5533, 5532, 1, 0, 0, 0, 5533, 5534, 1, 0, 0, 0, 5534, 5535, 1, 0, 0, + 0, 5535, 5536, 3, 856, 428, 0, 5536, 5537, 5, 974, 0, 0, 5537, 5538, 5, + 161, 0, 0, 5538, 5680, 1, 0, 0, 0, 5539, 5540, 5, 38, 0, 0, 5540, 5541, + 5, 1005, 0, 0, 5541, 5542, 3, 856, 428, 0, 5542, 5543, 5, 783, 0, 0, 5543, + 5544, 5, 769, 0, 0, 5544, 5680, 1, 0, 0, 0, 5545, 5546, 5, 38, 0, 0, 5546, + 5547, 5, 1005, 0, 0, 5547, 5548, 3, 856, 428, 0, 5548, 5549, 5, 974, 0, + 0, 5549, 5550, 5, 769, 0, 0, 5550, 5680, 1, 0, 0, 0, 5551, 5552, 5, 38, + 0, 0, 5552, 5554, 5, 1005, 0, 0, 5553, 5555, 3, 650, 325, 0, 5554, 5553, + 1, 0, 0, 0, 5554, 5555, 1, 0, 0, 0, 5555, 5556, 1, 0, 0, 0, 5556, 5557, + 3, 856, 428, 0, 5557, 5558, 3, 300, 150, 0, 5558, 5680, 1, 0, 0, 0, 5559, + 5560, 5, 38, 0, 0, 5560, 5562, 5, 1005, 0, 0, 5561, 5563, 3, 650, 325, + 0, 5562, 5561, 1, 0, 0, 0, 5562, 5563, 1, 0, 0, 0, 5563, 5564, 1, 0, 0, + 0, 5564, 5565, 3, 856, 428, 0, 5565, 5566, 3, 304, 152, 0, 5566, 5680, + 1, 0, 0, 0, 5567, 5568, 5, 38, 0, 0, 5568, 5570, 5, 1005, 0, 0, 5569, 5571, + 3, 650, 325, 0, 5570, 5569, 1, 0, 0, 0, 5570, 5571, 1, 0, 0, 0, 5571, 5572, + 1, 0, 0, 0, 5572, 5573, 3, 856, 428, 0, 5573, 5574, 5, 14, 0, 0, 5574, + 5575, 5, 723, 0, 0, 5575, 5576, 5, 8, 0, 0, 5576, 5577, 5, 608, 0, 0, 5577, + 5578, 3, 856, 428, 0, 5578, 5579, 5, 553, 0, 0, 5579, 5580, 3, 368, 184, + 0, 5580, 5680, 1, 0, 0, 0, 5581, 5582, 5, 38, 0, 0, 5582, 5584, 5, 1005, + 0, 0, 5583, 5585, 3, 650, 325, 0, 5584, 5583, 1, 0, 0, 0, 5584, 5585, 1, + 0, 0, 0, 5585, 5586, 1, 0, 0, 0, 5586, 5587, 3, 856, 428, 0, 5587, 5588, + 5, 249, 0, 0, 5588, 5589, 5, 723, 0, 0, 5589, 5590, 5, 8, 0, 0, 5590, 5591, + 5, 608, 0, 0, 5591, 5592, 3, 856, 428, 0, 5592, 5680, 1, 0, 0, 0, 5593, + 5594, 5, 38, 0, 0, 5594, 5596, 5, 1005, 0, 0, 5595, 5597, 3, 650, 325, + 0, 5596, 5595, 1, 0, 0, 0, 5596, 5597, 1, 0, 0, 0, 5597, 5598, 1, 0, 0, + 0, 5598, 5599, 3, 856, 428, 0, 5599, 5600, 5, 14, 0, 0, 5600, 5601, 5, + 723, 0, 0, 5601, 5602, 5, 8, 0, 0, 5602, 5603, 5, 608, 0, 0, 5603, 5604, + 3, 856, 428, 0, 5604, 5605, 5, 553, 0, 0, 5605, 5606, 3, 368, 184, 0, 5606, + 5607, 5, 1110, 0, 0, 5607, 5608, 5, 249, 0, 0, 5608, 5609, 5, 723, 0, 0, + 5609, 5610, 5, 8, 0, 0, 5610, 5611, 5, 608, 0, 0, 5611, 5612, 3, 856, 428, + 0, 5612, 5680, 1, 0, 0, 0, 5613, 5614, 5, 38, 0, 0, 5614, 5616, 5, 1005, + 0, 0, 5615, 5617, 3, 650, 325, 0, 5616, 5615, 1, 0, 0, 0, 5616, 5617, 1, + 0, 0, 0, 5617, 5618, 1, 0, 0, 0, 5618, 5619, 3, 856, 428, 0, 5619, 5620, + 5, 249, 0, 0, 5620, 5621, 5, 23, 0, 0, 5621, 5622, 5, 723, 0, 0, 5622, + 5623, 5, 8, 0, 0, 5623, 5624, 5, 607, 0, 0, 5624, 5680, 1, 0, 0, 0, 5625, + 5626, 5, 38, 0, 0, 5626, 5627, 5, 1005, 0, 0, 5627, 5628, 3, 856, 428, + 0, 5628, 5630, 3, 284, 142, 0, 5629, 5631, 5, 157, 0, 0, 5630, 5629, 1, + 0, 0, 0, 5630, 5631, 1, 0, 0, 0, 5631, 5632, 1, 0, 0, 0, 5632, 5633, 3, + 856, 428, 0, 5633, 5634, 5, 783, 0, 0, 5634, 5635, 5, 455, 0, 0, 5635, + 5636, 5, 608, 0, 0, 5636, 5644, 3, 856, 428, 0, 5637, 5638, 5, 992, 0, + 0, 5638, 5639, 5, 1104, 0, 0, 5639, 5640, 3, 874, 437, 0, 5640, 5641, 5, + 1110, 0, 0, 5641, 5642, 3, 876, 438, 0, 5642, 5643, 5, 1105, 0, 0, 5643, + 5645, 1, 0, 0, 0, 5644, 5637, 1, 0, 0, 0, 5644, 5645, 1, 0, 0, 0, 5645, + 5647, 1, 0, 0, 0, 5646, 5648, 5, 323, 0, 0, 5647, 5646, 1, 0, 0, 0, 5647, + 5648, 1, 0, 0, 0, 5648, 5680, 1, 0, 0, 0, 5649, 5650, 5, 38, 0, 0, 5650, + 5651, 5, 1005, 0, 0, 5651, 5652, 3, 856, 428, 0, 5652, 5654, 3, 284, 142, + 0, 5653, 5655, 5, 157, 0, 0, 5654, 5653, 1, 0, 0, 0, 5654, 5655, 1, 0, + 0, 0, 5655, 5656, 1, 0, 0, 0, 5656, 5657, 3, 856, 428, 0, 5657, 5658, 5, + 974, 0, 0, 5658, 5659, 5, 455, 0, 0, 5659, 5660, 5, 608, 0, 0, 5660, 5680, + 1, 0, 0, 0, 5661, 5662, 5, 38, 0, 0, 5662, 5663, 5, 1005, 0, 0, 5663, 5664, + 3, 856, 428, 0, 5664, 5666, 3, 284, 142, 0, 5665, 5667, 5, 157, 0, 0, 5666, + 5665, 1, 0, 0, 0, 5666, 5667, 1, 0, 0, 0, 5667, 5668, 1, 0, 0, 0, 5668, + 5669, 3, 856, 428, 0, 5669, 5670, 3, 300, 150, 0, 5670, 5680, 1, 0, 0, + 0, 5671, 5672, 5, 38, 0, 0, 5672, 5673, 5, 1005, 0, 0, 5673, 5674, 3, 856, + 428, 0, 5674, 5675, 3, 284, 142, 0, 5675, 5676, 5, 157, 0, 0, 5676, 5677, + 3, 856, 428, 0, 5677, 5678, 3, 304, 152, 0, 5678, 5680, 1, 0, 0, 0, 5679, + 5511, 1, 0, 0, 0, 5679, 5521, 1, 0, 0, 0, 5679, 5530, 1, 0, 0, 0, 5679, + 5539, 1, 0, 0, 0, 5679, 5545, 1, 0, 0, 0, 5679, 5551, 1, 0, 0, 0, 5679, + 5559, 1, 0, 0, 0, 5679, 5567, 1, 0, 0, 0, 5679, 5581, 1, 0, 0, 0, 5679, + 5593, 1, 0, 0, 0, 5679, 5613, 1, 0, 0, 0, 5679, 5625, 1, 0, 0, 0, 5679, + 5649, 1, 0, 0, 0, 5679, 5661, 1, 0, 0, 0, 5679, 5671, 1, 0, 0, 0, 5680, + 283, 1, 0, 0, 0, 5681, 5682, 7, 36, 0, 0, 5682, 285, 1, 0, 0, 0, 5683, + 5684, 5, 38, 0, 0, 5684, 5686, 5, 1011, 0, 0, 5685, 5687, 3, 650, 325, + 0, 5686, 5685, 1, 0, 0, 0, 5686, 5687, 1, 0, 0, 0, 5687, 5688, 1, 0, 0, + 0, 5688, 5689, 3, 296, 148, 0, 5689, 287, 1, 0, 0, 0, 5690, 5691, 3, 856, + 428, 0, 5691, 5692, 5, 257, 0, 0, 5692, 5693, 5, 307, 0, 0, 5693, 5694, + 5, 922, 0, 0, 5694, 5695, 5, 11, 0, 0, 5695, 5696, 3, 856, 428, 0, 5696, + 5697, 5, 1099, 0, 0, 5697, 5705, 3, 856, 428, 0, 5698, 5699, 5, 1110, 0, + 0, 5699, 5700, 3, 856, 428, 0, 5700, 5701, 5, 1099, 0, 0, 5701, 5702, 3, + 856, 428, 0, 5702, 5704, 1, 0, 0, 0, 5703, 5698, 1, 0, 0, 0, 5704, 5707, + 1, 0, 0, 0, 5705, 5703, 1, 0, 0, 0, 5705, 5706, 1, 0, 0, 0, 5706, 5709, + 1, 0, 0, 0, 5707, 5705, 1, 0, 0, 0, 5708, 5710, 3, 164, 82, 0, 5709, 5708, + 1, 0, 0, 0, 5709, 5710, 1, 0, 0, 0, 5710, 5744, 1, 0, 0, 0, 5711, 5712, + 3, 856, 428, 0, 5712, 5713, 5, 239, 0, 0, 5713, 5724, 5, 307, 0, 0, 5714, + 5715, 5, 922, 0, 0, 5715, 5716, 5, 11, 0, 0, 5716, 5717, 3, 856, 428, 0, + 5717, 5718, 5, 1099, 0, 0, 5718, 5719, 3, 856, 428, 0, 5719, 5720, 5, 1110, + 0, 0, 5720, 5721, 3, 856, 428, 0, 5721, 5722, 5, 1099, 0, 0, 5722, 5723, + 3, 856, 428, 0, 5723, 5725, 1, 0, 0, 0, 5724, 5714, 1, 0, 0, 0, 5724, 5725, + 1, 0, 0, 0, 5725, 5744, 1, 0, 0, 0, 5726, 5727, 3, 856, 428, 0, 5727, 5728, + 5, 619, 0, 0, 5728, 5744, 1, 0, 0, 0, 5729, 5731, 3, 650, 325, 0, 5730, + 5729, 1, 0, 0, 0, 5730, 5731, 1, 0, 0, 0, 5731, 5732, 1, 0, 0, 0, 5732, + 5733, 3, 856, 428, 0, 5733, 5734, 5, 783, 0, 0, 5734, 5735, 3, 646, 323, + 0, 5735, 5744, 1, 0, 0, 0, 5736, 5738, 3, 650, 325, 0, 5737, 5736, 1, 0, + 0, 0, 5737, 5738, 1, 0, 0, 0, 5738, 5739, 1, 0, 0, 0, 5739, 5740, 3, 856, + 428, 0, 5740, 5741, 5, 974, 0, 0, 5741, 5742, 5, 161, 0, 0, 5742, 5744, + 1, 0, 0, 0, 5743, 5690, 1, 0, 0, 0, 5743, 5711, 1, 0, 0, 0, 5743, 5726, + 1, 0, 0, 0, 5743, 5730, 1, 0, 0, 0, 5743, 5737, 1, 0, 0, 0, 5744, 289, + 1, 0, 0, 0, 5745, 5746, 5, 682, 0, 0, 5746, 5747, 5, 922, 0, 0, 5747, 5780, + 3, 856, 428, 0, 5748, 5749, 5, 693, 0, 0, 5749, 5780, 5, 587, 0, 0, 5750, + 5751, 5, 2, 0, 0, 5751, 5752, 5, 23, 0, 0, 5752, 5780, 5, 641, 0, 0, 5753, + 5754, 5, 14, 0, 0, 5754, 5755, 5, 231, 0, 0, 5755, 5756, 5, 60, 0, 0, 5756, + 5757, 5, 542, 0, 0, 5757, 5758, 5, 718, 0, 0, 5758, 5759, 3, 856, 428, + 0, 5759, 5760, 5, 922, 0, 0, 5760, 5761, 5, 770, 0, 0, 5761, 5762, 5, 394, + 0, 0, 5762, 5763, 3, 856, 428, 0, 5763, 5780, 1, 0, 0, 0, 5764, 5765, 5, + 681, 0, 0, 5765, 5771, 5, 231, 0, 0, 5766, 5767, 5, 60, 0, 0, 5767, 5768, + 5, 542, 0, 0, 5768, 5769, 5, 718, 0, 0, 5769, 5772, 3, 856, 428, 0, 5770, + 5772, 5, 61, 0, 0, 5771, 5766, 1, 0, 0, 0, 5771, 5770, 1, 0, 0, 0, 5772, + 5773, 1, 0, 0, 0, 5773, 5774, 5, 329, 0, 0, 5774, 5775, 5, 770, 0, 0, 5775, + 5776, 5, 394, 0, 0, 5776, 5780, 3, 856, 428, 0, 5777, 5780, 3, 300, 150, + 0, 5778, 5780, 3, 304, 152, 0, 5779, 5745, 1, 0, 0, 0, 5779, 5748, 1, 0, + 0, 0, 5779, 5750, 1, 0, 0, 0, 5779, 5753, 1, 0, 0, 0, 5779, 5764, 1, 0, + 0, 0, 5779, 5777, 1, 0, 0, 0, 5779, 5778, 1, 0, 0, 0, 5780, 291, 1, 0, + 0, 0, 5781, 5783, 3, 650, 325, 0, 5782, 5781, 1, 0, 0, 0, 5782, 5783, 1, + 0, 0, 0, 5783, 5784, 1, 0, 0, 0, 5784, 5785, 3, 856, 428, 0, 5785, 5786, + 5, 682, 0, 0, 5786, 5787, 5, 922, 0, 0, 5787, 5788, 3, 856, 428, 0, 5788, + 5850, 1, 0, 0, 0, 5789, 5791, 3, 650, 325, 0, 5790, 5789, 1, 0, 0, 0, 5790, + 5791, 1, 0, 0, 0, 5791, 5792, 1, 0, 0, 0, 5792, 5793, 3, 856, 428, 0, 5793, + 5794, 7, 37, 0, 0, 5794, 5795, 5, 30, 0, 0, 5795, 5800, 3, 852, 426, 0, + 5796, 5797, 5, 1110, 0, 0, 5797, 5799, 3, 852, 426, 0, 5798, 5796, 1, 0, + 0, 0, 5799, 5802, 1, 0, 0, 0, 5800, 5798, 1, 0, 0, 0, 5800, 5801, 1, 0, + 0, 0, 5801, 5850, 1, 0, 0, 0, 5802, 5800, 1, 0, 0, 0, 5803, 5804, 3, 856, + 428, 0, 5804, 5805, 5, 974, 0, 0, 5805, 5806, 5, 30, 0, 0, 5806, 5850, + 1, 0, 0, 0, 5807, 5808, 3, 856, 428, 0, 5808, 5809, 5, 783, 0, 0, 5809, + 5810, 5, 455, 0, 0, 5810, 5811, 5, 608, 0, 0, 5811, 5818, 3, 856, 428, + 0, 5812, 5813, 5, 1110, 0, 0, 5813, 5814, 5, 455, 0, 0, 5814, 5815, 5, + 608, 0, 0, 5815, 5817, 3, 856, 428, 0, 5816, 5812, 1, 0, 0, 0, 5817, 5820, + 1, 0, 0, 0, 5818, 5816, 1, 0, 0, 0, 5818, 5819, 1, 0, 0, 0, 5819, 5850, + 1, 0, 0, 0, 5820, 5818, 1, 0, 0, 0, 5821, 5822, 3, 856, 428, 0, 5822, 5823, + 5, 974, 0, 0, 5823, 5824, 5, 455, 0, 0, 5824, 5825, 5, 608, 0, 0, 5825, + 5832, 3, 856, 428, 0, 5826, 5827, 5, 1110, 0, 0, 5827, 5828, 5, 455, 0, + 0, 5828, 5829, 5, 608, 0, 0, 5829, 5831, 3, 856, 428, 0, 5830, 5826, 1, + 0, 0, 0, 5831, 5834, 1, 0, 0, 0, 5832, 5830, 1, 0, 0, 0, 5832, 5833, 1, + 0, 0, 0, 5833, 5850, 1, 0, 0, 0, 5834, 5832, 1, 0, 0, 0, 5835, 5837, 3, + 650, 325, 0, 5836, 5835, 1, 0, 0, 0, 5836, 5837, 1, 0, 0, 0, 5837, 5838, + 1, 0, 0, 0, 5838, 5839, 3, 856, 428, 0, 5839, 5840, 5, 783, 0, 0, 5840, + 5841, 3, 646, 323, 0, 5841, 5850, 1, 0, 0, 0, 5842, 5844, 3, 650, 325, + 0, 5843, 5842, 1, 0, 0, 0, 5843, 5844, 1, 0, 0, 0, 5844, 5845, 1, 0, 0, + 0, 5845, 5846, 3, 856, 428, 0, 5846, 5847, 5, 974, 0, 0, 5847, 5848, 5, + 161, 0, 0, 5848, 5850, 1, 0, 0, 0, 5849, 5782, 1, 0, 0, 0, 5849, 5790, + 1, 0, 0, 0, 5849, 5803, 1, 0, 0, 0, 5849, 5807, 1, 0, 0, 0, 5849, 5821, + 1, 0, 0, 0, 5849, 5836, 1, 0, 0, 0, 5849, 5843, 1, 0, 0, 0, 5850, 293, + 1, 0, 0, 0, 5851, 5853, 3, 650, 325, 0, 5852, 5851, 1, 0, 0, 0, 5852, 5853, + 1, 0, 0, 0, 5853, 5854, 1, 0, 0, 0, 5854, 5855, 3, 856, 428, 0, 5855, 5862, + 5, 783, 0, 0, 5856, 5857, 5, 28, 0, 0, 5857, 5858, 5, 1092, 0, 0, 5858, + 5859, 5, 1104, 0, 0, 5859, 5860, 3, 854, 427, 0, 5860, 5861, 5, 1105, 0, + 0, 5861, 5863, 1, 0, 0, 0, 5862, 5856, 1, 0, 0, 0, 5862, 5863, 1, 0, 0, + 0, 5863, 5870, 1, 0, 0, 0, 5864, 5865, 5, 104, 0, 0, 5865, 5866, 5, 1092, + 0, 0, 5866, 5867, 5, 1104, 0, 0, 5867, 5868, 3, 854, 427, 0, 5868, 5869, + 5, 1105, 0, 0, 5869, 5871, 1, 0, 0, 0, 5870, 5864, 1, 0, 0, 0, 5870, 5871, + 1, 0, 0, 0, 5871, 5873, 1, 0, 0, 0, 5872, 5874, 3, 646, 323, 0, 5873, 5872, + 1, 0, 0, 0, 5873, 5874, 1, 0, 0, 0, 5874, 5888, 1, 0, 0, 0, 5875, 5877, + 3, 650, 325, 0, 5876, 5875, 1, 0, 0, 0, 5876, 5877, 1, 0, 0, 0, 5877, 5878, + 1, 0, 0, 0, 5878, 5879, 3, 856, 428, 0, 5879, 5880, 5, 974, 0, 0, 5880, + 5881, 5, 161, 0, 0, 5881, 5888, 1, 0, 0, 0, 5882, 5883, 3, 856, 428, 0, + 5883, 5884, 5, 682, 0, 0, 5884, 5885, 5, 922, 0, 0, 5885, 5886, 3, 856, + 428, 0, 5886, 5888, 1, 0, 0, 0, 5887, 5852, 1, 0, 0, 0, 5887, 5876, 1, + 0, 0, 0, 5887, 5882, 1, 0, 0, 0, 5888, 295, 1, 0, 0, 0, 5889, 5891, 3, + 856, 428, 0, 5890, 5889, 1, 0, 0, 0, 5890, 5891, 1, 0, 0, 0, 5891, 5897, + 1, 0, 0, 0, 5892, 5898, 5, 870, 0, 0, 5893, 5895, 5, 703, 0, 0, 5894, 5896, + 3, 648, 324, 0, 5895, 5894, 1, 0, 0, 0, 5895, 5896, 1, 0, 0, 0, 5896, 5898, + 1, 0, 0, 0, 5897, 5892, 1, 0, 0, 0, 5897, 5893, 1, 0, 0, 0, 5898, 5927, + 1, 0, 0, 0, 5899, 5901, 3, 856, 428, 0, 5900, 5899, 1, 0, 0, 0, 5900, 5901, + 1, 0, 0, 0, 5901, 5902, 1, 0, 0, 0, 5902, 5903, 5, 2, 0, 0, 5903, 5904, + 5, 23, 0, 0, 5904, 5927, 5, 641, 0, 0, 5905, 5906, 3, 856, 428, 0, 5906, + 5907, 5, 682, 0, 0, 5907, 5908, 5, 922, 0, 0, 5908, 5909, 3, 856, 428, + 0, 5909, 5927, 1, 0, 0, 0, 5910, 5911, 3, 856, 428, 0, 5911, 5912, 3, 300, + 150, 0, 5912, 5927, 1, 0, 0, 0, 5913, 5914, 3, 856, 428, 0, 5914, 5915, + 3, 304, 152, 0, 5915, 5927, 1, 0, 0, 0, 5916, 5917, 3, 856, 428, 0, 5917, + 5918, 5, 974, 0, 0, 5918, 5923, 3, 856, 428, 0, 5919, 5920, 5, 1110, 0, + 0, 5920, 5922, 3, 856, 428, 0, 5921, 5919, 1, 0, 0, 0, 5922, 5925, 1, 0, + 0, 0, 5923, 5921, 1, 0, 0, 0, 5923, 5924, 1, 0, 0, 0, 5924, 5927, 1, 0, + 0, 0, 5925, 5923, 1, 0, 0, 0, 5926, 5890, 1, 0, 0, 0, 5926, 5900, 1, 0, + 0, 0, 5926, 5905, 1, 0, 0, 0, 5926, 5910, 1, 0, 0, 0, 5926, 5913, 1, 0, + 0, 0, 5926, 5916, 1, 0, 0, 0, 5927, 297, 1, 0, 0, 0, 5928, 5930, 5, 783, + 0, 0, 5929, 5931, 3, 126, 63, 0, 5930, 5929, 1, 0, 0, 0, 5930, 5931, 1, + 0, 0, 0, 5931, 5933, 1, 0, 0, 0, 5932, 5934, 3, 128, 64, 0, 5933, 5932, + 1, 0, 0, 0, 5933, 5934, 1, 0, 0, 0, 5934, 5936, 1, 0, 0, 0, 5935, 5937, + 3, 134, 67, 0, 5936, 5935, 1, 0, 0, 0, 5936, 5937, 1, 0, 0, 0, 5937, 5965, + 1, 0, 0, 0, 5938, 5939, 5, 974, 0, 0, 5939, 5942, 3, 846, 423, 0, 5940, + 5941, 5, 1110, 0, 0, 5941, 5943, 3, 846, 423, 0, 5942, 5940, 1, 0, 0, 0, + 5942, 5943, 1, 0, 0, 0, 5943, 5965, 1, 0, 0, 0, 5944, 5945, 5, 783, 0, + 0, 5945, 5946, 5, 696, 0, 0, 5946, 5947, 5, 1092, 0, 0, 5947, 5965, 3, + 856, 428, 0, 5948, 5965, 3, 300, 150, 0, 5949, 5965, 3, 304, 152, 0, 5950, + 5951, 3, 856, 428, 0, 5951, 5952, 5, 682, 0, 0, 5952, 5953, 5, 922, 0, + 0, 5953, 5957, 3, 856, 428, 0, 5954, 5955, 5, 753, 0, 0, 5955, 5956, 5, + 1092, 0, 0, 5956, 5958, 3, 450, 225, 0, 5957, 5954, 1, 0, 0, 0, 5957, 5958, + 1, 0, 0, 0, 5958, 5965, 1, 0, 0, 0, 5959, 5960, 3, 856, 428, 0, 5960, 5961, + 5, 249, 0, 0, 5961, 5962, 5, 549, 0, 0, 5962, 5963, 5, 980, 0, 0, 5963, + 5965, 1, 0, 0, 0, 5964, 5928, 1, 0, 0, 0, 5964, 5938, 1, 0, 0, 0, 5964, + 5944, 1, 0, 0, 0, 5964, 5948, 1, 0, 0, 0, 5964, 5949, 1, 0, 0, 0, 5964, + 5950, 1, 0, 0, 0, 5964, 5959, 1, 0, 0, 0, 5965, 299, 1, 0, 0, 0, 5966, + 5967, 5, 783, 0, 0, 5967, 5968, 3, 302, 151, 0, 5968, 301, 1, 0, 0, 0, + 5969, 5970, 5, 887, 0, 0, 5970, 5971, 3, 856, 428, 0, 5971, 5972, 5, 1092, + 0, 0, 5972, 5980, 3, 840, 420, 0, 5973, 5974, 5, 1110, 0, 0, 5974, 5975, + 3, 856, 428, 0, 5975, 5976, 5, 1092, 0, 0, 5976, 5977, 3, 840, 420, 0, + 5977, 5979, 1, 0, 0, 0, 5978, 5973, 1, 0, 0, 0, 5979, 5982, 1, 0, 0, 0, + 5980, 5978, 1, 0, 0, 0, 5980, 5981, 1, 0, 0, 0, 5981, 303, 1, 0, 0, 0, + 5982, 5980, 1, 0, 0, 0, 5983, 5984, 5, 974, 0, 0, 5984, 5985, 5, 887, 0, + 0, 5985, 5990, 3, 856, 428, 0, 5986, 5987, 5, 1110, 0, 0, 5987, 5989, 3, + 856, 428, 0, 5988, 5986, 1, 0, 0, 0, 5989, 5992, 1, 0, 0, 0, 5990, 5988, + 1, 0, 0, 0, 5990, 5991, 1, 0, 0, 0, 5991, 305, 1, 0, 0, 0, 5992, 5990, + 1, 0, 0, 0, 5993, 6035, 3, 308, 154, 0, 5994, 6035, 3, 310, 155, 0, 5995, + 6035, 3, 316, 158, 0, 5996, 6035, 3, 318, 159, 0, 5997, 6035, 3, 320, 160, + 0, 5998, 6035, 3, 322, 161, 0, 5999, 6035, 3, 324, 162, 0, 6000, 6035, + 3, 336, 168, 0, 6001, 6035, 3, 338, 169, 0, 6002, 6035, 3, 348, 174, 0, + 6003, 6035, 3, 352, 176, 0, 6004, 6035, 3, 360, 180, 0, 6005, 6035, 3, + 362, 181, 0, 6006, 6035, 3, 364, 182, 0, 6007, 6035, 3, 370, 185, 0, 6008, + 6035, 3, 372, 186, 0, 6009, 6035, 3, 378, 189, 0, 6010, 6035, 3, 380, 190, + 0, 6011, 6035, 3, 388, 194, 0, 6012, 6035, 3, 390, 195, 0, 6013, 6035, + 3, 392, 196, 0, 6014, 6035, 3, 394, 197, 0, 6015, 6035, 3, 396, 198, 0, + 6016, 6035, 3, 398, 199, 0, 6017, 6035, 3, 400, 200, 0, 6018, 6035, 3, + 404, 202, 0, 6019, 6035, 3, 406, 203, 0, 6020, 6035, 3, 408, 204, 0, 6021, + 6035, 3, 418, 209, 0, 6022, 6035, 3, 420, 210, 0, 6023, 6035, 3, 422, 211, + 0, 6024, 6035, 3, 462, 231, 0, 6025, 6035, 3, 470, 235, 0, 6026, 6035, + 3, 482, 241, 0, 6027, 6035, 3, 514, 257, 0, 6028, 6035, 3, 516, 258, 0, + 6029, 6035, 3, 518, 259, 0, 6030, 6035, 3, 528, 264, 0, 6031, 6035, 3, + 534, 267, 0, 6032, 6035, 3, 538, 269, 0, 6033, 6035, 3, 540, 270, 0, 6034, + 5993, 1, 0, 0, 0, 6034, 5994, 1, 0, 0, 0, 6034, 5995, 1, 0, 0, 0, 6034, + 5996, 1, 0, 0, 0, 6034, 5997, 1, 0, 0, 0, 6034, 5998, 1, 0, 0, 0, 6034, + 5999, 1, 0, 0, 0, 6034, 6000, 1, 0, 0, 0, 6034, 6001, 1, 0, 0, 0, 6034, + 6002, 1, 0, 0, 0, 6034, 6003, 1, 0, 0, 0, 6034, 6004, 1, 0, 0, 0, 6034, + 6005, 1, 0, 0, 0, 6034, 6006, 1, 0, 0, 0, 6034, 6007, 1, 0, 0, 0, 6034, + 6008, 1, 0, 0, 0, 6034, 6009, 1, 0, 0, 0, 6034, 6010, 1, 0, 0, 0, 6034, + 6011, 1, 0, 0, 0, 6034, 6012, 1, 0, 0, 0, 6034, 6013, 1, 0, 0, 0, 6034, + 6014, 1, 0, 0, 0, 6034, 6015, 1, 0, 0, 0, 6034, 6016, 1, 0, 0, 0, 6034, + 6017, 1, 0, 0, 0, 6034, 6018, 1, 0, 0, 0, 6034, 6019, 1, 0, 0, 0, 6034, + 6020, 1, 0, 0, 0, 6034, 6021, 1, 0, 0, 0, 6034, 6022, 1, 0, 0, 0, 6034, + 6023, 1, 0, 0, 0, 6034, 6024, 1, 0, 0, 0, 6034, 6025, 1, 0, 0, 0, 6034, + 6026, 1, 0, 0, 0, 6034, 6027, 1, 0, 0, 0, 6034, 6028, 1, 0, 0, 0, 6034, + 6029, 1, 0, 0, 0, 6034, 6030, 1, 0, 0, 0, 6034, 6031, 1, 0, 0, 0, 6034, + 6032, 1, 0, 0, 0, 6034, 6033, 1, 0, 0, 0, 6035, 307, 1, 0, 0, 0, 6036, + 6037, 5, 190, 0, 0, 6037, 6038, 5, 9, 0, 0, 6038, 6039, 3, 856, 428, 0, + 6039, 6040, 5, 16, 0, 0, 6040, 6041, 5, 1092, 0, 0, 6041, 6042, 3, 856, + 428, 0, 6042, 6043, 5, 17, 0, 0, 6043, 6044, 5, 1092, 0, 0, 6044, 6048, + 3, 852, 426, 0, 6045, 6046, 5, 320, 0, 0, 6046, 6047, 5, 1092, 0, 0, 6047, + 6049, 3, 856, 428, 0, 6048, 6045, 1, 0, 0, 0, 6048, 6049, 1, 0, 0, 0, 6049, + 6053, 1, 0, 0, 0, 6050, 6051, 5, 421, 0, 0, 6051, 6052, 5, 1092, 0, 0, + 6052, 6054, 3, 856, 428, 0, 6053, 6050, 1, 0, 0, 0, 6053, 6054, 1, 0, 0, + 0, 6054, 6055, 1, 0, 0, 0, 6055, 6056, 5, 254, 0, 0, 6056, 6057, 5, 1092, + 0, 0, 6057, 6061, 3, 852, 426, 0, 6058, 6059, 5, 491, 0, 0, 6059, 6060, + 5, 1092, 0, 0, 6060, 6062, 3, 450, 225, 0, 6061, 6058, 1, 0, 0, 0, 6061, + 6062, 1, 0, 0, 0, 6062, 6063, 1, 0, 0, 0, 6063, 6064, 5, 252, 0, 0, 6064, + 6065, 5, 1092, 0, 0, 6065, 6069, 7, 38, 0, 0, 6066, 6067, 5, 675, 0, 0, + 6067, 6068, 5, 1092, 0, 0, 6068, 6070, 3, 848, 424, 0, 6069, 6066, 1, 0, + 0, 0, 6069, 6070, 1, 0, 0, 0, 6070, 6074, 1, 0, 0, 0, 6071, 6072, 5, 673, + 0, 0, 6072, 6073, 5, 1092, 0, 0, 6073, 6075, 3, 850, 425, 0, 6074, 6071, + 1, 0, 0, 0, 6074, 6075, 1, 0, 0, 0, 6075, 6077, 1, 0, 0, 0, 6076, 6078, + 3, 646, 323, 0, 6077, 6076, 1, 0, 0, 0, 6077, 6078, 1, 0, 0, 0, 6078, 309, + 1, 0, 0, 0, 6079, 6081, 5, 190, 0, 0, 6080, 6082, 3, 654, 327, 0, 6081, + 6080, 1, 0, 0, 0, 6081, 6082, 1, 0, 0, 0, 6082, 6083, 1, 0, 0, 0, 6083, + 6085, 5, 21, 0, 0, 6084, 6086, 3, 652, 326, 0, 6085, 6084, 1, 0, 0, 0, + 6085, 6086, 1, 0, 0, 0, 6086, 6087, 1, 0, 0, 0, 6087, 6088, 3, 856, 428, + 0, 6088, 6089, 5, 1011, 0, 0, 6089, 6090, 5, 1092, 0, 0, 6090, 6091, 3, + 856, 428, 0, 6091, 6092, 5, 755, 0, 0, 6092, 6093, 5, 1092, 0, 0, 6093, + 6094, 3, 852, 426, 0, 6094, 6095, 5, 364, 0, 0, 6095, 6096, 5, 1104, 0, + 0, 6096, 6097, 5, 285, 0, 0, 6097, 6098, 5, 1104, 0, 0, 6098, 6099, 3, + 312, 156, 0, 6099, 6100, 5, 1105, 0, 0, 6100, 6101, 5, 1105, 0, 0, 6101, + 6102, 5, 897, 0, 0, 6102, 6103, 3, 314, 157, 0, 6103, 311, 1, 0, 0, 0, + 6104, 6108, 3, 942, 471, 0, 6105, 6108, 3, 714, 357, 0, 6106, 6108, 3, + 532, 266, 0, 6107, 6104, 1, 0, 0, 0, 6107, 6105, 1, 0, 0, 0, 6107, 6106, + 1, 0, 0, 0, 6108, 313, 1, 0, 0, 0, 6109, 6110, 3, 4, 2, 0, 6110, 315, 1, + 0, 0, 0, 6111, 6113, 5, 190, 0, 0, 6112, 6114, 3, 654, 327, 0, 6113, 6112, + 1, 0, 0, 0, 6113, 6114, 1, 0, 0, 0, 6114, 6115, 1, 0, 0, 0, 6115, 6116, + 5, 44, 0, 0, 6116, 6118, 5, 394, 0, 0, 6117, 6119, 3, 652, 326, 0, 6118, + 6117, 1, 0, 0, 0, 6118, 6119, 1, 0, 0, 0, 6119, 6120, 1, 0, 0, 0, 6120, + 6121, 3, 856, 428, 0, 6121, 6122, 5, 50, 0, 0, 6122, 6123, 5, 1092, 0, + 0, 6123, 6124, 3, 856, 428, 0, 6124, 6125, 5, 46, 0, 0, 6125, 6126, 5, + 1092, 0, 0, 6126, 6130, 3, 852, 426, 0, 6127, 6128, 5, 49, 0, 0, 6128, + 6129, 5, 1092, 0, 0, 6129, 6131, 3, 852, 426, 0, 6130, 6127, 1, 0, 0, 0, + 6130, 6131, 1, 0, 0, 0, 6131, 6132, 1, 0, 0, 0, 6132, 6133, 5, 45, 0, 0, + 6133, 6134, 5, 1092, 0, 0, 6134, 6135, 5, 1104, 0, 0, 6135, 6136, 3, 852, + 426, 0, 6136, 6143, 5, 1105, 0, 0, 6137, 6138, 5, 47, 0, 0, 6138, 6139, + 5, 1092, 0, 0, 6139, 6140, 5, 1104, 0, 0, 6140, 6141, 3, 852, 426, 0, 6141, + 6142, 5, 1105, 0, 0, 6142, 6144, 1, 0, 0, 0, 6143, 6137, 1, 0, 0, 0, 6143, + 6144, 1, 0, 0, 0, 6144, 6145, 1, 0, 0, 0, 6145, 6146, 5, 258, 0, 0, 6146, + 6147, 5, 1092, 0, 0, 6147, 6149, 3, 450, 225, 0, 6148, 6150, 3, 646, 323, + 0, 6149, 6148, 1, 0, 0, 0, 6149, 6150, 1, 0, 0, 0, 6150, 6226, 1, 0, 0, + 0, 6151, 6153, 5, 190, 0, 0, 6152, 6154, 3, 654, 327, 0, 6153, 6152, 1, + 0, 0, 0, 6153, 6154, 1, 0, 0, 0, 6154, 6155, 1, 0, 0, 0, 6155, 6156, 5, + 44, 0, 0, 6156, 6158, 5, 394, 0, 0, 6157, 6159, 3, 652, 326, 0, 6158, 6157, + 1, 0, 0, 0, 6158, 6159, 1, 0, 0, 0, 6159, 6160, 1, 0, 0, 0, 6160, 6161, + 3, 856, 428, 0, 6161, 6162, 5, 50, 0, 0, 6162, 6163, 5, 1092, 0, 0, 6163, + 6164, 3, 856, 428, 0, 6164, 6165, 5, 91, 0, 0, 6165, 6166, 5, 1092, 0, + 0, 6166, 6167, 3, 852, 426, 0, 6167, 6168, 5, 85, 0, 0, 6168, 6169, 5, + 1092, 0, 0, 6169, 6173, 3, 852, 426, 0, 6170, 6171, 5, 49, 0, 0, 6171, + 6172, 5, 1092, 0, 0, 6172, 6174, 3, 852, 426, 0, 6173, 6170, 1, 0, 0, 0, + 6173, 6174, 1, 0, 0, 0, 6174, 6175, 1, 0, 0, 0, 6175, 6176, 5, 45, 0, 0, + 6176, 6177, 5, 1092, 0, 0, 6177, 6178, 5, 1104, 0, 0, 6178, 6179, 3, 852, + 426, 0, 6179, 6186, 5, 1105, 0, 0, 6180, 6181, 5, 47, 0, 0, 6181, 6182, + 5, 1092, 0, 0, 6182, 6183, 5, 1104, 0, 0, 6183, 6184, 3, 852, 426, 0, 6184, + 6185, 5, 1105, 0, 0, 6185, 6187, 1, 0, 0, 0, 6186, 6180, 1, 0, 0, 0, 6186, + 6187, 1, 0, 0, 0, 6187, 6188, 1, 0, 0, 0, 6188, 6189, 5, 258, 0, 0, 6189, + 6190, 5, 1092, 0, 0, 6190, 6192, 3, 450, 225, 0, 6191, 6193, 3, 646, 323, + 0, 6192, 6191, 1, 0, 0, 0, 6192, 6193, 1, 0, 0, 0, 6193, 6226, 1, 0, 0, + 0, 6194, 6195, 5, 190, 0, 0, 6195, 6196, 3, 654, 327, 0, 6196, 6197, 5, + 44, 0, 0, 6197, 6198, 5, 394, 0, 0, 6198, 6199, 3, 652, 326, 0, 6199, 6200, + 3, 856, 428, 0, 6200, 6201, 5, 50, 0, 0, 6201, 6202, 5, 1092, 0, 0, 6202, + 6203, 3, 856, 428, 0, 6203, 6204, 5, 346, 0, 0, 6204, 6205, 5, 1092, 0, + 0, 6205, 6206, 3, 852, 426, 0, 6206, 6207, 5, 45, 0, 0, 6207, 6208, 5, + 1092, 0, 0, 6208, 6209, 5, 1104, 0, 0, 6209, 6210, 3, 852, 426, 0, 6210, + 6217, 5, 1105, 0, 0, 6211, 6212, 5, 47, 0, 0, 6212, 6213, 5, 1092, 0, 0, + 6213, 6214, 5, 1104, 0, 0, 6214, 6215, 3, 852, 426, 0, 6215, 6216, 5, 1105, + 0, 0, 6216, 6218, 1, 0, 0, 0, 6217, 6211, 1, 0, 0, 0, 6217, 6218, 1, 0, + 0, 0, 6218, 6219, 1, 0, 0, 0, 6219, 6220, 5, 258, 0, 0, 6220, 6221, 5, + 1092, 0, 0, 6221, 6223, 3, 450, 225, 0, 6222, 6224, 3, 646, 323, 0, 6223, + 6222, 1, 0, 0, 0, 6223, 6224, 1, 0, 0, 0, 6224, 6226, 1, 0, 0, 0, 6225, + 6111, 1, 0, 0, 0, 6225, 6151, 1, 0, 0, 0, 6225, 6194, 1, 0, 0, 0, 6226, + 317, 1, 0, 0, 0, 6227, 6229, 5, 190, 0, 0, 6228, 6230, 3, 654, 327, 0, + 6229, 6228, 1, 0, 0, 0, 6229, 6230, 1, 0, 0, 0, 6230, 6231, 1, 0, 0, 0, + 6231, 6233, 7, 39, 0, 0, 6232, 6234, 3, 652, 326, 0, 6233, 6232, 1, 0, + 0, 0, 6233, 6234, 1, 0, 0, 0, 6234, 6235, 1, 0, 0, 0, 6235, 6236, 3, 856, + 428, 0, 6236, 6237, 5, 149, 0, 0, 6237, 6253, 3, 878, 439, 0, 6238, 6239, + 3, 328, 164, 0, 6239, 6249, 5, 1104, 0, 0, 6240, 6241, 5, 904, 0, 0, 6241, + 6242, 5, 1089, 0, 0, 6242, 6250, 3, 852, 426, 0, 6243, 6244, 5, 544, 0, + 0, 6244, 6245, 5, 1089, 0, 0, 6245, 6250, 3, 852, 426, 0, 6246, 6247, 5, + 834, 0, 0, 6247, 6248, 5, 1089, 0, 0, 6248, 6250, 3, 856, 428, 0, 6249, + 6240, 1, 0, 0, 0, 6249, 6243, 1, 0, 0, 0, 6249, 6246, 1, 0, 0, 0, 6250, + 6251, 1, 0, 0, 0, 6251, 6252, 5, 1105, 0, 0, 6252, 6254, 1, 0, 0, 0, 6253, + 6238, 1, 0, 0, 0, 6253, 6254, 1, 0, 0, 0, 6254, 6275, 1, 0, 0, 0, 6255, + 6257, 5, 190, 0, 0, 6256, 6258, 3, 654, 327, 0, 6257, 6256, 1, 0, 0, 0, + 6257, 6258, 1, 0, 0, 0, 6258, 6265, 1, 0, 0, 0, 6259, 6266, 5, 822, 0, + 0, 6260, 6261, 5, 314, 0, 0, 6261, 6266, 5, 325, 0, 0, 6262, 6266, 5, 775, + 0, 0, 6263, 6266, 5, 857, 0, 0, 6264, 6266, 5, 891, 0, 0, 6265, 6259, 1, + 0, 0, 0, 6265, 6260, 1, 0, 0, 0, 6265, 6262, 1, 0, 0, 0, 6265, 6263, 1, + 0, 0, 0, 6265, 6264, 1, 0, 0, 0, 6266, 6268, 1, 0, 0, 0, 6267, 6269, 3, + 652, 326, 0, 6268, 6267, 1, 0, 0, 0, 6268, 6269, 1, 0, 0, 0, 6269, 6270, + 1, 0, 0, 0, 6270, 6271, 3, 878, 439, 0, 6271, 6272, 5, 149, 0, 0, 6272, + 6273, 3, 878, 439, 0, 6273, 6275, 1, 0, 0, 0, 6274, 6227, 1, 0, 0, 0, 6274, + 6255, 1, 0, 0, 0, 6275, 319, 1, 0, 0, 0, 6276, 6277, 5, 190, 0, 0, 6277, + 6279, 5, 172, 0, 0, 6278, 6280, 3, 652, 326, 0, 6279, 6278, 1, 0, 0, 0, + 6279, 6280, 1, 0, 0, 0, 6280, 6281, 1, 0, 0, 0, 6281, 6296, 3, 856, 428, + 0, 6282, 6284, 3, 646, 323, 0, 6283, 6282, 1, 0, 0, 0, 6283, 6284, 1, 0, + 0, 0, 6284, 6297, 1, 0, 0, 0, 6285, 6286, 5, 56, 0, 0, 6286, 6287, 5, 686, + 0, 0, 6287, 6288, 5, 542, 0, 0, 6288, 6289, 3, 856, 428, 0, 6289, 6290, + 5, 1099, 0, 0, 6290, 6291, 3, 856, 428, 0, 6291, 6292, 5, 1099, 0, 0, 6292, + 6294, 3, 856, 428, 0, 6293, 6295, 3, 646, 323, 0, 6294, 6293, 1, 0, 0, + 0, 6294, 6295, 1, 0, 0, 0, 6295, 6297, 1, 0, 0, 0, 6296, 6283, 1, 0, 0, + 0, 6296, 6285, 1, 0, 0, 0, 6297, 321, 1, 0, 0, 0, 6298, 6300, 5, 190, 0, + 0, 6299, 6301, 3, 654, 327, 0, 6300, 6299, 1, 0, 0, 0, 6300, 6301, 1, 0, + 0, 0, 6301, 6303, 1, 0, 0, 0, 6302, 6304, 5, 936, 0, 0, 6303, 6302, 1, + 0, 0, 0, 6303, 6304, 1, 0, 0, 0, 6304, 6305, 1, 0, 0, 0, 6305, 6307, 5, + 207, 0, 0, 6306, 6308, 3, 652, 326, 0, 6307, 6306, 1, 0, 0, 0, 6307, 6308, + 1, 0, 0, 0, 6308, 6309, 1, 0, 0, 0, 6309, 6311, 3, 856, 428, 0, 6310, 6312, + 3, 326, 163, 0, 6311, 6310, 1, 0, 0, 0, 6311, 6312, 1, 0, 0, 0, 6312, 6316, + 1, 0, 0, 0, 6313, 6314, 5, 209, 0, 0, 6314, 6315, 5, 1092, 0, 0, 6315, + 6317, 3, 880, 440, 0, 6316, 6313, 1, 0, 0, 0, 6316, 6317, 1, 0, 0, 0, 6317, + 6321, 1, 0, 0, 0, 6318, 6319, 5, 467, 0, 0, 6319, 6320, 5, 1092, 0, 0, + 6320, 6322, 3, 880, 440, 0, 6321, 6318, 1, 0, 0, 0, 6321, 6322, 1, 0, 0, + 0, 6322, 6324, 1, 0, 0, 0, 6323, 6325, 3, 130, 65, 0, 6324, 6323, 1, 0, + 0, 0, 6324, 6325, 1, 0, 0, 0, 6325, 6327, 1, 0, 0, 0, 6326, 6328, 3, 488, + 244, 0, 6327, 6326, 1, 0, 0, 0, 6327, 6328, 1, 0, 0, 0, 6328, 6330, 1, + 0, 0, 0, 6329, 6331, 3, 646, 323, 0, 6330, 6329, 1, 0, 0, 0, 6330, 6331, + 1, 0, 0, 0, 6331, 323, 1, 0, 0, 0, 6332, 6334, 5, 190, 0, 0, 6333, 6335, + 3, 654, 327, 0, 6334, 6333, 1, 0, 0, 0, 6334, 6335, 1, 0, 0, 0, 6335, 6336, + 1, 0, 0, 0, 6336, 6337, 5, 250, 0, 0, 6337, 6338, 5, 880, 0, 0, 6338, 6339, + 3, 856, 428, 0, 6339, 6340, 5, 890, 0, 0, 6340, 6343, 5, 1092, 0, 0, 6341, + 6344, 3, 852, 426, 0, 6342, 6344, 5, 247, 0, 0, 6343, 6341, 1, 0, 0, 0, + 6343, 6342, 1, 0, 0, 0, 6344, 6345, 1, 0, 0, 0, 6345, 6346, 5, 1011, 0, + 0, 6346, 6347, 5, 1092, 0, 0, 6347, 6348, 3, 856, 428, 0, 6348, 6349, 5, + 56, 0, 0, 6349, 6350, 3, 932, 466, 0, 6350, 325, 1, 0, 0, 0, 6351, 6352, + 5, 149, 0, 0, 6352, 6368, 3, 856, 428, 0, 6353, 6354, 3, 328, 164, 0, 6354, + 6364, 5, 1104, 0, 0, 6355, 6356, 5, 904, 0, 0, 6356, 6357, 5, 1089, 0, + 0, 6357, 6365, 3, 852, 426, 0, 6358, 6359, 5, 544, 0, 0, 6359, 6360, 5, + 1089, 0, 0, 6360, 6365, 3, 852, 426, 0, 6361, 6362, 5, 834, 0, 0, 6362, + 6363, 5, 1089, 0, 0, 6363, 6365, 3, 856, 428, 0, 6364, 6355, 1, 0, 0, 0, + 6364, 6358, 1, 0, 0, 0, 6364, 6361, 1, 0, 0, 0, 6365, 6366, 1, 0, 0, 0, + 6366, 6367, 5, 1105, 0, 0, 6367, 6369, 1, 0, 0, 0, 6368, 6353, 1, 0, 0, + 0, 6368, 6369, 1, 0, 0, 0, 6369, 327, 1, 0, 0, 0, 6370, 6371, 7, 40, 0, + 0, 6371, 329, 1, 0, 0, 0, 6372, 6373, 3, 852, 426, 0, 6373, 6374, 5, 1092, + 0, 0, 6374, 6375, 3, 852, 426, 0, 6375, 331, 1, 0, 0, 0, 6376, 6377, 7, + 41, 0, 0, 6377, 333, 1, 0, 0, 0, 6378, 6379, 5, 165, 0, 0, 6379, 6380, + 5, 1092, 0, 0, 6380, 6381, 3, 332, 166, 0, 6381, 335, 1, 0, 0, 0, 6382, + 6384, 5, 190, 0, 0, 6383, 6385, 3, 654, 327, 0, 6384, 6383, 1, 0, 0, 0, + 6384, 6385, 1, 0, 0, 0, 6385, 6387, 1, 0, 0, 0, 6386, 6388, 5, 769, 0, + 0, 6387, 6386, 1, 0, 0, 0, 6387, 6388, 1, 0, 0, 0, 6388, 6389, 1, 0, 0, + 0, 6389, 6390, 5, 291, 0, 0, 6390, 6391, 5, 331, 0, 0, 6391, 6392, 3, 878, + 439, 0, 6392, 6404, 5, 1104, 0, 0, 6393, 6394, 3, 844, 422, 0, 6394, 6401, + 3, 842, 421, 0, 6395, 6396, 5, 1110, 0, 0, 6396, 6397, 3, 844, 422, 0, + 6397, 6398, 3, 842, 421, 0, 6398, 6400, 1, 0, 0, 0, 6399, 6395, 1, 0, 0, + 0, 6400, 6403, 1, 0, 0, 0, 6401, 6399, 1, 0, 0, 0, 6401, 6402, 1, 0, 0, + 0, 6402, 6405, 1, 0, 0, 0, 6403, 6401, 1, 0, 0, 0, 6404, 6393, 1, 0, 0, + 0, 6404, 6405, 1, 0, 0, 0, 6405, 6406, 1, 0, 0, 0, 6406, 6407, 5, 1105, + 0, 0, 6407, 6408, 5, 706, 0, 0, 6408, 6410, 3, 902, 451, 0, 6409, 6411, + 3, 1054, 527, 0, 6410, 6409, 1, 0, 0, 0, 6410, 6411, 1, 0, 0, 0, 6411, + 6424, 1, 0, 0, 0, 6412, 6413, 5, 114, 0, 0, 6413, 6414, 5, 553, 0, 0, 6414, + 6415, 5, 522, 0, 0, 6415, 6425, 5, 389, 0, 0, 6416, 6417, 5, 706, 0, 0, + 6417, 6418, 5, 522, 0, 0, 6418, 6419, 5, 553, 0, 0, 6419, 6420, 5, 522, + 0, 0, 6420, 6423, 5, 389, 0, 0, 6421, 6423, 5, 859, 0, 0, 6422, 6416, 1, + 0, 0, 0, 6422, 6421, 1, 0, 0, 0, 6423, 6425, 1, 0, 0, 0, 6424, 6412, 1, + 0, 0, 0, 6424, 6422, 1, 0, 0, 0, 6424, 6425, 1, 0, 0, 0, 6425, 6427, 1, + 0, 0, 0, 6426, 6428, 7, 42, 0, 0, 6427, 6426, 1, 0, 0, 0, 6427, 6428, 1, + 0, 0, 0, 6428, 6430, 1, 0, 0, 0, 6429, 6431, 3, 646, 323, 0, 6430, 6429, + 1, 0, 0, 0, 6430, 6431, 1, 0, 0, 0, 6431, 6432, 1, 0, 0, 0, 6432, 6433, + 5, 48, 0, 0, 6433, 6434, 5, 1092, 0, 0, 6434, 6448, 3, 856, 428, 0, 6435, + 6436, 5, 357, 0, 0, 6436, 6437, 5, 1092, 0, 0, 6437, 6438, 5, 1104, 0, + 0, 6438, 6443, 3, 330, 165, 0, 6439, 6440, 5, 1110, 0, 0, 6440, 6442, 3, + 330, 165, 0, 6441, 6439, 1, 0, 0, 0, 6442, 6445, 1, 0, 0, 0, 6443, 6441, + 1, 0, 0, 0, 6443, 6444, 1, 0, 0, 0, 6444, 6446, 1, 0, 0, 0, 6445, 6443, + 1, 0, 0, 0, 6446, 6447, 5, 1105, 0, 0, 6447, 6449, 1, 0, 0, 0, 6448, 6435, + 1, 0, 0, 0, 6448, 6449, 1, 0, 0, 0, 6449, 6463, 1, 0, 0, 0, 6450, 6451, + 5, 179, 0, 0, 6451, 6452, 5, 1092, 0, 0, 6452, 6453, 5, 1104, 0, 0, 6453, + 6458, 3, 856, 428, 0, 6454, 6455, 5, 1110, 0, 0, 6455, 6457, 3, 856, 428, + 0, 6456, 6454, 1, 0, 0, 0, 6457, 6460, 1, 0, 0, 0, 6458, 6456, 1, 0, 0, + 0, 6458, 6459, 1, 0, 0, 0, 6459, 6461, 1, 0, 0, 0, 6460, 6458, 1, 0, 0, + 0, 6461, 6462, 5, 1105, 0, 0, 6462, 6464, 1, 0, 0, 0, 6463, 6450, 1, 0, + 0, 0, 6463, 6464, 1, 0, 0, 0, 6464, 6468, 1, 0, 0, 0, 6465, 6466, 5, 464, + 0, 0, 6466, 6467, 5, 1092, 0, 0, 6467, 6469, 3, 880, 440, 0, 6468, 6465, + 1, 0, 0, 0, 6468, 6469, 1, 0, 0, 0, 6469, 6471, 1, 0, 0, 0, 6470, 6472, + 3, 334, 167, 0, 6471, 6470, 1, 0, 0, 0, 6471, 6472, 1, 0, 0, 0, 6472, 6476, + 1, 0, 0, 0, 6473, 6474, 5, 689, 0, 0, 6474, 6475, 5, 1092, 0, 0, 6475, + 6477, 3, 856, 428, 0, 6476, 6473, 1, 0, 0, 0, 6476, 6477, 1, 0, 0, 0, 6477, + 6481, 1, 0, 0, 0, 6478, 6479, 5, 697, 0, 0, 6479, 6480, 5, 1092, 0, 0, + 6480, 6482, 3, 856, 428, 0, 6481, 6478, 1, 0, 0, 0, 6481, 6482, 1, 0, 0, + 0, 6482, 6483, 1, 0, 0, 0, 6483, 6484, 5, 56, 0, 0, 6484, 6485, 3, 852, + 426, 0, 6485, 337, 1, 0, 0, 0, 6486, 6488, 5, 190, 0, 0, 6487, 6489, 3, + 654, 327, 0, 6488, 6487, 1, 0, 0, 0, 6488, 6489, 1, 0, 0, 0, 6489, 6490, + 1, 0, 0, 0, 6490, 6491, 5, 291, 0, 0, 6491, 6493, 5, 880, 0, 0, 6492, 6494, + 3, 652, 326, 0, 6493, 6492, 1, 0, 0, 0, 6493, 6494, 1, 0, 0, 0, 6494, 6495, + 1, 0, 0, 0, 6495, 6496, 3, 878, 439, 0, 6496, 6497, 5, 1104, 0, 0, 6497, + 6498, 3, 342, 171, 0, 6498, 6500, 5, 1105, 0, 0, 6499, 6501, 3, 468, 234, + 0, 6500, 6499, 1, 0, 0, 0, 6500, 6501, 1, 0, 0, 0, 6501, 6503, 1, 0, 0, + 0, 6502, 6504, 3, 1010, 505, 0, 6503, 6502, 1, 0, 0, 0, 6503, 6504, 1, + 0, 0, 0, 6504, 6506, 1, 0, 0, 0, 6505, 6507, 5, 1020, 0, 0, 6506, 6505, + 1, 0, 0, 0, 6506, 6507, 1, 0, 0, 0, 6507, 6508, 1, 0, 0, 0, 6508, 6509, + 5, 440, 0, 0, 6509, 6510, 5, 1092, 0, 0, 6510, 6514, 3, 102, 51, 0, 6511, + 6512, 5, 672, 0, 0, 6512, 6513, 5, 1092, 0, 0, 6513, 6515, 3, 450, 225, + 0, 6514, 6511, 1, 0, 0, 0, 6514, 6515, 1, 0, 0, 0, 6515, 6519, 1, 0, 0, + 0, 6516, 6517, 5, 70, 0, 0, 6517, 6518, 5, 1092, 0, 0, 6518, 6520, 3, 450, + 225, 0, 6519, 6516, 1, 0, 0, 0, 6519, 6520, 1, 0, 0, 0, 6520, 6522, 1, + 0, 0, 0, 6521, 6523, 3, 872, 436, 0, 6522, 6521, 1, 0, 0, 0, 6522, 6523, + 1, 0, 0, 0, 6523, 6524, 1, 0, 0, 0, 6524, 6528, 3, 44, 22, 0, 6525, 6526, + 5, 81, 0, 0, 6526, 6527, 5, 1092, 0, 0, 6527, 6529, 3, 852, 426, 0, 6528, + 6525, 1, 0, 0, 0, 6528, 6529, 1, 0, 0, 0, 6529, 6531, 1, 0, 0, 0, 6530, + 6532, 3, 472, 236, 0, 6531, 6530, 1, 0, 0, 0, 6531, 6532, 1, 0, 0, 0, 6532, + 6534, 1, 0, 0, 0, 6533, 6535, 3, 490, 245, 0, 6534, 6533, 1, 0, 0, 0, 6534, + 6535, 1, 0, 0, 0, 6535, 6537, 1, 0, 0, 0, 6536, 6538, 3, 488, 244, 0, 6537, + 6536, 1, 0, 0, 0, 6537, 6538, 1, 0, 0, 0, 6538, 6540, 1, 0, 0, 0, 6539, + 6541, 3, 646, 323, 0, 6540, 6539, 1, 0, 0, 0, 6540, 6541, 1, 0, 0, 0, 6541, + 6630, 1, 0, 0, 0, 6542, 6544, 5, 190, 0, 0, 6543, 6545, 3, 654, 327, 0, + 6544, 6543, 1, 0, 0, 0, 6544, 6545, 1, 0, 0, 0, 6545, 6546, 1, 0, 0, 0, + 6546, 6547, 5, 291, 0, 0, 6547, 6549, 5, 880, 0, 0, 6548, 6550, 3, 652, + 326, 0, 6549, 6548, 1, 0, 0, 0, 6549, 6550, 1, 0, 0, 0, 6550, 6551, 1, + 0, 0, 0, 6551, 6552, 3, 878, 439, 0, 6552, 6553, 5, 1104, 0, 0, 6553, 6554, + 3, 342, 171, 0, 6554, 6556, 5, 1105, 0, 0, 6555, 6557, 3, 468, 234, 0, + 6556, 6555, 1, 0, 0, 0, 6556, 6557, 1, 0, 0, 0, 6557, 6559, 1, 0, 0, 0, + 6558, 6560, 3, 1010, 505, 0, 6559, 6558, 1, 0, 0, 0, 6559, 6560, 1, 0, + 0, 0, 6560, 6562, 1, 0, 0, 0, 6561, 6563, 5, 1020, 0, 0, 6562, 6561, 1, + 0, 0, 0, 6562, 6563, 1, 0, 0, 0, 6563, 6564, 1, 0, 0, 0, 6564, 6565, 5, + 440, 0, 0, 6565, 6566, 5, 1092, 0, 0, 6566, 6567, 3, 102, 51, 0, 6567, + 6568, 5, 586, 0, 0, 6568, 6569, 5, 1092, 0, 0, 6569, 6570, 5, 987, 0, 0, + 6570, 6572, 3, 44, 22, 0, 6571, 6573, 3, 472, 236, 0, 6572, 6571, 1, 0, + 0, 0, 6572, 6573, 1, 0, 0, 0, 6573, 6575, 1, 0, 0, 0, 6574, 6576, 3, 490, + 245, 0, 6575, 6574, 1, 0, 0, 0, 6575, 6576, 1, 0, 0, 0, 6576, 6578, 1, + 0, 0, 0, 6577, 6579, 3, 488, 244, 0, 6578, 6577, 1, 0, 0, 0, 6578, 6579, + 1, 0, 0, 0, 6579, 6581, 1, 0, 0, 0, 6580, 6582, 3, 646, 323, 0, 6581, 6580, + 1, 0, 0, 0, 6581, 6582, 1, 0, 0, 0, 6582, 6630, 1, 0, 0, 0, 6583, 6585, + 5, 190, 0, 0, 6584, 6586, 3, 654, 327, 0, 6585, 6584, 1, 0, 0, 0, 6585, + 6586, 1, 0, 0, 0, 6586, 6587, 1, 0, 0, 0, 6587, 6588, 5, 291, 0, 0, 6588, + 6590, 5, 880, 0, 0, 6589, 6591, 3, 652, 326, 0, 6590, 6589, 1, 0, 0, 0, + 6590, 6591, 1, 0, 0, 0, 6591, 6592, 1, 0, 0, 0, 6592, 6593, 3, 878, 439, + 0, 6593, 6594, 5, 1104, 0, 0, 6594, 6595, 3, 342, 171, 0, 6595, 6597, 5, + 1105, 0, 0, 6596, 6598, 3, 468, 234, 0, 6597, 6596, 1, 0, 0, 0, 6597, 6598, + 1, 0, 0, 0, 6598, 6600, 1, 0, 0, 0, 6599, 6601, 3, 1010, 505, 0, 6600, + 6599, 1, 0, 0, 0, 6600, 6601, 1, 0, 0, 0, 6601, 6603, 1, 0, 0, 0, 6602, + 6604, 5, 1020, 0, 0, 6603, 6602, 1, 0, 0, 0, 6603, 6604, 1, 0, 0, 0, 6604, + 6605, 1, 0, 0, 0, 6605, 6606, 5, 440, 0, 0, 6606, 6607, 5, 1092, 0, 0, + 6607, 6608, 3, 102, 51, 0, 6608, 6609, 5, 586, 0, 0, 6609, 6610, 5, 1092, + 0, 0, 6610, 6611, 5, 987, 0, 0, 6611, 6615, 3, 44, 22, 0, 6612, 6613, 5, + 885, 0, 0, 6613, 6614, 5, 1092, 0, 0, 6614, 6616, 5, 233, 0, 0, 6615, 6612, + 1, 0, 0, 0, 6615, 6616, 1, 0, 0, 0, 6616, 6618, 1, 0, 0, 0, 6617, 6619, + 3, 472, 236, 0, 6618, 6617, 1, 0, 0, 0, 6618, 6619, 1, 0, 0, 0, 6619, 6621, + 1, 0, 0, 0, 6620, 6622, 3, 490, 245, 0, 6621, 6620, 1, 0, 0, 0, 6621, 6622, + 1, 0, 0, 0, 6622, 6624, 1, 0, 0, 0, 6623, 6625, 3, 488, 244, 0, 6624, 6623, + 1, 0, 0, 0, 6624, 6625, 1, 0, 0, 0, 6625, 6627, 1, 0, 0, 0, 6626, 6628, + 3, 646, 323, 0, 6627, 6626, 1, 0, 0, 0, 6627, 6628, 1, 0, 0, 0, 6628, 6630, + 1, 0, 0, 0, 6629, 6486, 1, 0, 0, 0, 6629, 6542, 1, 0, 0, 0, 6629, 6583, + 1, 0, 0, 0, 6630, 339, 1, 0, 0, 0, 6631, 6632, 3, 874, 437, 0, 6632, 6633, + 3, 902, 451, 0, 6633, 6636, 5, 56, 0, 0, 6634, 6637, 3, 886, 443, 0, 6635, + 6637, 3, 856, 428, 0, 6636, 6634, 1, 0, 0, 0, 6636, 6635, 1, 0, 0, 0, 6637, + 6639, 1, 0, 0, 0, 6638, 6640, 3, 252, 126, 0, 6639, 6638, 1, 0, 0, 0, 6639, + 6640, 1, 0, 0, 0, 6640, 341, 1, 0, 0, 0, 6641, 6646, 3, 340, 170, 0, 6642, + 6643, 5, 1110, 0, 0, 6643, 6645, 3, 340, 170, 0, 6644, 6642, 1, 0, 0, 0, + 6645, 6648, 1, 0, 0, 0, 6646, 6644, 1, 0, 0, 0, 6646, 6647, 1, 0, 0, 0, + 6647, 343, 1, 0, 0, 0, 6648, 6646, 1, 0, 0, 0, 6649, 6650, 3, 856, 428, + 0, 6650, 6651, 5, 1099, 0, 0, 6651, 6652, 3, 856, 428, 0, 6652, 345, 1, + 0, 0, 0, 6653, 6654, 5, 770, 0, 0, 6654, 6658, 5, 395, 0, 0, 6655, 6656, + 5, 44, 0, 0, 6656, 6658, 5, 395, 0, 0, 6657, 6653, 1, 0, 0, 0, 6657, 6655, + 1, 0, 0, 0, 6658, 347, 1, 0, 0, 0, 6659, 6660, 5, 190, 0, 0, 6660, 6661, + 5, 307, 0, 0, 6661, 6663, 5, 350, 0, 0, 6662, 6664, 3, 652, 326, 0, 6663, + 6662, 1, 0, 0, 0, 6663, 6664, 1, 0, 0, 0, 6664, 6665, 1, 0, 0, 0, 6665, + 6666, 3, 856, 428, 0, 6666, 6667, 5, 541, 0, 0, 6667, 6668, 5, 1092, 0, + 0, 6668, 6673, 3, 836, 418, 0, 6669, 6670, 5, 1110, 0, 0, 6670, 6672, 3, + 836, 418, 0, 6671, 6669, 1, 0, 0, 0, 6672, 6675, 1, 0, 0, 0, 6673, 6671, + 1, 0, 0, 0, 6673, 6674, 1, 0, 0, 0, 6674, 6686, 1, 0, 0, 0, 6675, 6673, + 1, 0, 0, 0, 6676, 6677, 5, 26, 0, 0, 6677, 6678, 5, 1092, 0, 0, 6678, 6683, + 3, 856, 428, 0, 6679, 6680, 5, 1110, 0, 0, 6680, 6682, 3, 856, 428, 0, + 6681, 6679, 1, 0, 0, 0, 6682, 6685, 1, 0, 0, 0, 6683, 6681, 1, 0, 0, 0, + 6683, 6684, 1, 0, 0, 0, 6684, 6687, 1, 0, 0, 0, 6685, 6683, 1, 0, 0, 0, + 6686, 6676, 1, 0, 0, 0, 6686, 6687, 1, 0, 0, 0, 6687, 6698, 1, 0, 0, 0, + 6688, 6689, 5, 29, 0, 0, 6689, 6690, 5, 1092, 0, 0, 6690, 6695, 3, 856, + 428, 0, 6691, 6692, 5, 1110, 0, 0, 6692, 6694, 3, 856, 428, 0, 6693, 6691, + 1, 0, 0, 0, 6694, 6697, 1, 0, 0, 0, 6695, 6693, 1, 0, 0, 0, 6695, 6696, + 1, 0, 0, 0, 6696, 6699, 1, 0, 0, 0, 6697, 6695, 1, 0, 0, 0, 6698, 6688, + 1, 0, 0, 0, 6698, 6699, 1, 0, 0, 0, 6699, 6710, 1, 0, 0, 0, 6700, 6701, + 5, 27, 0, 0, 6701, 6702, 5, 1092, 0, 0, 6702, 6707, 3, 346, 173, 0, 6703, + 6704, 5, 1110, 0, 0, 6704, 6706, 3, 346, 173, 0, 6705, 6703, 1, 0, 0, 0, + 6706, 6709, 1, 0, 0, 0, 6707, 6705, 1, 0, 0, 0, 6707, 6708, 1, 0, 0, 0, + 6708, 6711, 1, 0, 0, 0, 6709, 6707, 1, 0, 0, 0, 6710, 6700, 1, 0, 0, 0, + 6710, 6711, 1, 0, 0, 0, 6711, 6712, 1, 0, 0, 0, 6712, 6713, 5, 25, 0, 0, + 6713, 6714, 5, 1092, 0, 0, 6714, 6719, 3, 344, 172, 0, 6715, 6716, 5, 1110, + 0, 0, 6716, 6718, 3, 344, 172, 0, 6717, 6715, 1, 0, 0, 0, 6718, 6721, 1, + 0, 0, 0, 6719, 6717, 1, 0, 0, 0, 6719, 6720, 1, 0, 0, 0, 6720, 6725, 1, + 0, 0, 0, 6721, 6719, 1, 0, 0, 0, 6722, 6723, 5, 367, 0, 0, 6723, 6724, + 5, 252, 0, 0, 6724, 6726, 5, 131, 0, 0, 6725, 6722, 1, 0, 0, 0, 6725, 6726, + 1, 0, 0, 0, 6726, 6730, 1, 0, 0, 0, 6727, 6728, 5, 688, 0, 0, 6728, 6729, + 5, 1092, 0, 0, 6729, 6731, 3, 852, 426, 0, 6730, 6727, 1, 0, 0, 0, 6730, + 6731, 1, 0, 0, 0, 6731, 6749, 1, 0, 0, 0, 6732, 6733, 5, 190, 0, 0, 6733, + 6734, 5, 307, 0, 0, 6734, 6736, 5, 350, 0, 0, 6735, 6737, 3, 652, 326, + 0, 6736, 6735, 1, 0, 0, 0, 6736, 6737, 1, 0, 0, 0, 6737, 6738, 1, 0, 0, + 0, 6738, 6739, 3, 856, 428, 0, 6739, 6740, 5, 56, 0, 0, 6740, 6741, 5, + 686, 0, 0, 6741, 6742, 5, 542, 0, 0, 6742, 6743, 3, 856, 428, 0, 6743, + 6744, 5, 1099, 0, 0, 6744, 6745, 3, 856, 428, 0, 6745, 6746, 5, 1099, 0, + 0, 6746, 6747, 3, 856, 428, 0, 6747, 6749, 1, 0, 0, 0, 6748, 6659, 1, 0, + 0, 0, 6748, 6732, 1, 0, 0, 0, 6749, 349, 1, 0, 0, 0, 6750, 6751, 7, 43, + 0, 0, 6751, 351, 1, 0, 0, 0, 6752, 6754, 5, 190, 0, 0, 6753, 6755, 3, 654, + 327, 0, 6754, 6753, 1, 0, 0, 0, 6754, 6755, 1, 0, 0, 0, 6755, 6756, 1, + 0, 0, 0, 6756, 6757, 5, 314, 0, 0, 6757, 6759, 5, 325, 0, 0, 6758, 6760, + 3, 652, 326, 0, 6759, 6758, 1, 0, 0, 0, 6759, 6760, 1, 0, 0, 0, 6760, 6761, + 1, 0, 0, 0, 6761, 6765, 3, 878, 439, 0, 6762, 6763, 5, 954, 0, 0, 6763, + 6764, 5, 1092, 0, 0, 6764, 6766, 3, 350, 175, 0, 6765, 6762, 1, 0, 0, 0, + 6765, 6766, 1, 0, 0, 0, 6766, 6770, 1, 0, 0, 0, 6767, 6769, 3, 426, 213, + 0, 6768, 6767, 1, 0, 0, 0, 6769, 6772, 1, 0, 0, 0, 6770, 6768, 1, 0, 0, + 0, 6770, 6771, 1, 0, 0, 0, 6771, 6774, 1, 0, 0, 0, 6772, 6770, 1, 0, 0, + 0, 6773, 6775, 3, 646, 323, 0, 6774, 6773, 1, 0, 0, 0, 6774, 6775, 1, 0, + 0, 0, 6775, 353, 1, 0, 0, 0, 6776, 6777, 3, 844, 422, 0, 6777, 6778, 3, + 842, 421, 0, 6778, 355, 1, 0, 0, 0, 6779, 6780, 3, 874, 437, 0, 6780, 6781, + 3, 902, 451, 0, 6781, 357, 1, 0, 0, 0, 6782, 6785, 3, 852, 426, 0, 6783, + 6785, 5, 1082, 0, 0, 6784, 6782, 1, 0, 0, 0, 6784, 6783, 1, 0, 0, 0, 6785, + 359, 1, 0, 0, 0, 6786, 6788, 5, 190, 0, 0, 6787, 6789, 3, 654, 327, 0, + 6788, 6787, 1, 0, 0, 0, 6788, 6789, 1, 0, 0, 0, 6789, 6791, 1, 0, 0, 0, + 6790, 6792, 5, 769, 0, 0, 6791, 6790, 1, 0, 0, 0, 6791, 6792, 1, 0, 0, + 0, 6792, 6793, 1, 0, 0, 0, 6793, 6794, 5, 331, 0, 0, 6794, 6795, 3, 878, + 439, 0, 6795, 6804, 5, 1104, 0, 0, 6796, 6801, 3, 354, 177, 0, 6797, 6798, + 5, 1110, 0, 0, 6798, 6800, 3, 354, 177, 0, 6799, 6797, 1, 0, 0, 0, 6800, + 6803, 1, 0, 0, 0, 6801, 6799, 1, 0, 0, 0, 6801, 6802, 1, 0, 0, 0, 6802, + 6805, 1, 0, 0, 0, 6803, 6801, 1, 0, 0, 0, 6804, 6796, 1, 0, 0, 0, 6804, + 6805, 1, 0, 0, 0, 6805, 6806, 1, 0, 0, 0, 6806, 6807, 5, 1105, 0, 0, 6807, + 6822, 5, 706, 0, 0, 6808, 6823, 3, 902, 451, 0, 6809, 6810, 5, 880, 0, + 0, 6810, 6819, 5, 1104, 0, 0, 6811, 6816, 3, 356, 178, 0, 6812, 6813, 5, + 1110, 0, 0, 6813, 6815, 3, 356, 178, 0, 6814, 6812, 1, 0, 0, 0, 6815, 6818, + 1, 0, 0, 0, 6816, 6814, 1, 0, 0, 0, 6816, 6817, 1, 0, 0, 0, 6817, 6820, + 1, 0, 0, 0, 6818, 6816, 1, 0, 0, 0, 6819, 6811, 1, 0, 0, 0, 6819, 6820, + 1, 0, 0, 0, 6820, 6821, 1, 0, 0, 0, 6821, 6823, 5, 1105, 0, 0, 6822, 6808, + 1, 0, 0, 0, 6822, 6809, 1, 0, 0, 0, 6823, 6825, 1, 0, 0, 0, 6824, 6826, + 3, 1054, 527, 0, 6825, 6824, 1, 0, 0, 0, 6825, 6826, 1, 0, 0, 0, 6826, + 6827, 1, 0, 0, 0, 6827, 6828, 5, 418, 0, 0, 6828, 6839, 5, 402, 0, 0, 6829, + 6830, 5, 114, 0, 0, 6830, 6831, 5, 553, 0, 0, 6831, 6832, 5, 522, 0, 0, + 6832, 6840, 5, 389, 0, 0, 6833, 6834, 5, 706, 0, 0, 6834, 6835, 5, 522, + 0, 0, 6835, 6836, 5, 553, 0, 0, 6836, 6837, 5, 522, 0, 0, 6837, 6840, 5, + 389, 0, 0, 6838, 6840, 5, 859, 0, 0, 6839, 6829, 1, 0, 0, 0, 6839, 6833, + 1, 0, 0, 0, 6839, 6838, 1, 0, 0, 0, 6839, 6840, 1, 0, 0, 0, 6840, 6842, + 1, 0, 0, 0, 6841, 6843, 7, 42, 0, 0, 6842, 6841, 1, 0, 0, 0, 6842, 6843, + 1, 0, 0, 0, 6843, 6845, 1, 0, 0, 0, 6844, 6846, 3, 646, 323, 0, 6845, 6844, + 1, 0, 0, 0, 6845, 6846, 1, 0, 0, 0, 6846, 6847, 1, 0, 0, 0, 6847, 6848, + 5, 56, 0, 0, 6848, 6849, 3, 358, 179, 0, 6849, 6916, 1, 0, 0, 0, 6850, + 6852, 5, 190, 0, 0, 6851, 6853, 3, 654, 327, 0, 6852, 6851, 1, 0, 0, 0, + 6852, 6853, 1, 0, 0, 0, 6853, 6855, 1, 0, 0, 0, 6854, 6856, 5, 769, 0, + 0, 6855, 6854, 1, 0, 0, 0, 6855, 6856, 1, 0, 0, 0, 6856, 6857, 1, 0, 0, + 0, 6857, 6858, 5, 331, 0, 0, 6858, 6859, 3, 878, 439, 0, 6859, 6868, 5, + 1104, 0, 0, 6860, 6865, 3, 354, 177, 0, 6861, 6862, 5, 1110, 0, 0, 6862, + 6864, 3, 354, 177, 0, 6863, 6861, 1, 0, 0, 0, 6864, 6867, 1, 0, 0, 0, 6865, + 6863, 1, 0, 0, 0, 6865, 6866, 1, 0, 0, 0, 6866, 6869, 1, 0, 0, 0, 6867, + 6865, 1, 0, 0, 0, 6868, 6860, 1, 0, 0, 0, 6868, 6869, 1, 0, 0, 0, 6869, + 6870, 1, 0, 0, 0, 6870, 6871, 5, 1105, 0, 0, 6871, 6886, 5, 706, 0, 0, + 6872, 6887, 3, 902, 451, 0, 6873, 6874, 5, 880, 0, 0, 6874, 6883, 5, 1104, + 0, 0, 6875, 6880, 3, 356, 178, 0, 6876, 6877, 5, 1110, 0, 0, 6877, 6879, + 3, 356, 178, 0, 6878, 6876, 1, 0, 0, 0, 6879, 6882, 1, 0, 0, 0, 6880, 6878, + 1, 0, 0, 0, 6880, 6881, 1, 0, 0, 0, 6881, 6884, 1, 0, 0, 0, 6882, 6880, + 1, 0, 0, 0, 6883, 6875, 1, 0, 0, 0, 6883, 6884, 1, 0, 0, 0, 6884, 6885, + 1, 0, 0, 0, 6885, 6887, 5, 1105, 0, 0, 6886, 6872, 1, 0, 0, 0, 6886, 6873, + 1, 0, 0, 0, 6887, 6889, 1, 0, 0, 0, 6888, 6890, 3, 1054, 527, 0, 6889, + 6888, 1, 0, 0, 0, 6889, 6890, 1, 0, 0, 0, 6890, 6901, 1, 0, 0, 0, 6891, + 6892, 5, 114, 0, 0, 6892, 6893, 5, 553, 0, 0, 6893, 6894, 5, 522, 0, 0, + 6894, 6902, 5, 389, 0, 0, 6895, 6896, 5, 706, 0, 0, 6896, 6897, 5, 522, + 0, 0, 6897, 6898, 5, 553, 0, 0, 6898, 6899, 5, 522, 0, 0, 6899, 6902, 5, + 389, 0, 0, 6900, 6902, 5, 859, 0, 0, 6901, 6891, 1, 0, 0, 0, 6901, 6895, + 1, 0, 0, 0, 6901, 6900, 1, 0, 0, 0, 6901, 6902, 1, 0, 0, 0, 6902, 6904, + 1, 0, 0, 0, 6903, 6905, 7, 42, 0, 0, 6904, 6903, 1, 0, 0, 0, 6904, 6905, + 1, 0, 0, 0, 6905, 6907, 1, 0, 0, 0, 6906, 6908, 5, 471, 0, 0, 6907, 6906, + 1, 0, 0, 0, 6907, 6908, 1, 0, 0, 0, 6908, 6910, 1, 0, 0, 0, 6909, 6911, + 3, 646, 323, 0, 6910, 6909, 1, 0, 0, 0, 6910, 6911, 1, 0, 0, 0, 6911, 6912, + 1, 0, 0, 0, 6912, 6913, 5, 56, 0, 0, 6913, 6914, 3, 358, 179, 0, 6914, + 6916, 1, 0, 0, 0, 6915, 6786, 1, 0, 0, 0, 6915, 6850, 1, 0, 0, 0, 6916, + 361, 1, 0, 0, 0, 6917, 6918, 5, 190, 0, 0, 6918, 6919, 5, 452, 0, 0, 6919, + 6920, 5, 9, 0, 0, 6920, 6921, 3, 856, 428, 0, 6921, 6922, 5, 16, 0, 0, + 6922, 6923, 5, 1092, 0, 0, 6923, 6924, 3, 856, 428, 0, 6924, 6925, 5, 1110, + 0, 0, 6925, 6926, 5, 17, 0, 0, 6926, 6927, 5, 1092, 0, 0, 6927, 6928, 3, + 852, 426, 0, 6928, 6929, 5, 1110, 0, 0, 6929, 6930, 5, 954, 0, 0, 6930, + 6931, 5, 1092, 0, 0, 6931, 6934, 5, 651, 0, 0, 6932, 6933, 5, 1110, 0, + 0, 6933, 6935, 3, 646, 323, 0, 6934, 6932, 1, 0, 0, 0, 6934, 6935, 1, 0, + 0, 0, 6935, 363, 1, 0, 0, 0, 6936, 6938, 5, 190, 0, 0, 6937, 6939, 3, 654, + 327, 0, 6938, 6937, 1, 0, 0, 0, 6938, 6939, 1, 0, 0, 0, 6939, 6940, 1, + 0, 0, 0, 6940, 6941, 5, 455, 0, 0, 6941, 6943, 5, 608, 0, 0, 6942, 6944, + 3, 652, 326, 0, 6943, 6942, 1, 0, 0, 0, 6943, 6944, 1, 0, 0, 0, 6944, 6945, + 1, 0, 0, 0, 6945, 6946, 3, 878, 439, 0, 6946, 6947, 5, 56, 0, 0, 6947, + 6948, 5, 1104, 0, 0, 6948, 6949, 3, 844, 422, 0, 6949, 6954, 3, 842, 421, + 0, 6950, 6951, 5, 1110, 0, 0, 6951, 6952, 3, 844, 422, 0, 6952, 6953, 3, + 842, 421, 0, 6953, 6955, 1, 0, 0, 0, 6954, 6950, 1, 0, 0, 0, 6954, 6955, + 1, 0, 0, 0, 6955, 6956, 1, 0, 0, 0, 6956, 6957, 5, 1105, 0, 0, 6957, 6958, + 5, 706, 0, 0, 6958, 6959, 3, 842, 421, 0, 6959, 6960, 5, 1088, 0, 0, 6960, + 6962, 3, 886, 443, 0, 6961, 6963, 3, 646, 323, 0, 6962, 6961, 1, 0, 0, + 0, 6962, 6963, 1, 0, 0, 0, 6963, 365, 1, 0, 0, 0, 6964, 6965, 3, 878, 439, + 0, 6965, 6966, 5, 1092, 0, 0, 6966, 6967, 3, 852, 426, 0, 6967, 367, 1, + 0, 0, 0, 6968, 6969, 5, 1104, 0, 0, 6969, 6970, 3, 876, 438, 0, 6970, 6971, + 5, 1105, 0, 0, 6971, 369, 1, 0, 0, 0, 6972, 6974, 5, 190, 0, 0, 6973, 6975, + 3, 654, 327, 0, 6974, 6973, 1, 0, 0, 0, 6974, 6975, 1, 0, 0, 0, 6975, 6977, + 1, 0, 0, 0, 6976, 6978, 5, 769, 0, 0, 6977, 6976, 1, 0, 0, 0, 6977, 6978, + 1, 0, 0, 0, 6978, 6979, 1, 0, 0, 0, 6979, 6980, 5, 463, 0, 0, 6980, 6982, + 5, 1005, 0, 0, 6981, 6983, 3, 652, 326, 0, 6982, 6981, 1, 0, 0, 0, 6982, + 6983, 1, 0, 0, 0, 6983, 6984, 1, 0, 0, 0, 6984, 6986, 3, 878, 439, 0, 6985, + 6987, 3, 472, 236, 0, 6986, 6985, 1, 0, 0, 0, 6986, 6987, 1, 0, 0, 0, 6987, + 6989, 1, 0, 0, 0, 6988, 6990, 3, 368, 184, 0, 6989, 6988, 1, 0, 0, 0, 6989, + 6990, 1, 0, 0, 0, 6990, 6992, 1, 0, 0, 0, 6991, 6993, 3, 490, 245, 0, 6992, + 6991, 1, 0, 0, 0, 6992, 6993, 1, 0, 0, 0, 6993, 6995, 1, 0, 0, 0, 6994, + 6996, 3, 488, 244, 0, 6995, 6994, 1, 0, 0, 0, 6995, 6996, 1, 0, 0, 0, 6996, + 6998, 1, 0, 0, 0, 6997, 6999, 3, 646, 323, 0, 6998, 6997, 1, 0, 0, 0, 6998, + 6999, 1, 0, 0, 0, 6999, 7001, 1, 0, 0, 0, 7000, 7002, 3, 492, 246, 0, 7001, + 7000, 1, 0, 0, 0, 7001, 7002, 1, 0, 0, 0, 7002, 7003, 1, 0, 0, 0, 7003, + 7004, 5, 56, 0, 0, 7004, 7005, 3, 942, 471, 0, 7005, 371, 1, 0, 0, 0, 7006, + 7008, 5, 190, 0, 0, 7007, 7009, 3, 654, 327, 0, 7008, 7007, 1, 0, 0, 0, + 7008, 7009, 1, 0, 0, 0, 7009, 7010, 1, 0, 0, 0, 7010, 7011, 5, 496, 0, + 0, 7011, 7012, 5, 608, 0, 0, 7012, 7013, 3, 856, 428, 0, 7013, 7014, 5, + 28, 0, 0, 7014, 7015, 5, 1092, 0, 0, 7015, 7017, 5, 1104, 0, 0, 7016, 7018, + 3, 854, 427, 0, 7017, 7016, 1, 0, 0, 0, 7017, 7018, 1, 0, 0, 0, 7018, 7019, + 1, 0, 0, 0, 7019, 7027, 5, 1105, 0, 0, 7020, 7021, 5, 104, 0, 0, 7021, + 7022, 5, 1092, 0, 0, 7022, 7024, 5, 1104, 0, 0, 7023, 7025, 3, 854, 427, + 0, 7024, 7023, 1, 0, 0, 0, 7024, 7025, 1, 0, 0, 0, 7025, 7026, 1, 0, 0, + 0, 7026, 7028, 5, 1105, 0, 0, 7027, 7020, 1, 0, 0, 0, 7027, 7028, 1, 0, + 0, 0, 7028, 7030, 1, 0, 0, 0, 7029, 7031, 3, 646, 323, 0, 7030, 7029, 1, + 0, 0, 0, 7030, 7031, 1, 0, 0, 0, 7031, 373, 1, 0, 0, 0, 7032, 7033, 5, + 515, 0, 0, 7033, 7034, 5, 1092, 0, 0, 7034, 7035, 5, 334, 0, 0, 7035, 7036, + 5, 335, 0, 0, 7036, 7037, 5, 1092, 0, 0, 7037, 7049, 3, 852, 426, 0, 7038, + 7039, 5, 515, 0, 0, 7039, 7040, 5, 1092, 0, 0, 7040, 7041, 5, 86, 0, 0, + 7041, 7042, 5, 90, 0, 0, 7042, 7043, 5, 1092, 0, 0, 7043, 7044, 3, 852, + 426, 0, 7044, 7045, 5, 91, 0, 0, 7045, 7046, 5, 1092, 0, 0, 7046, 7047, + 3, 852, 426, 0, 7047, 7049, 1, 0, 0, 0, 7048, 7032, 1, 0, 0, 0, 7048, 7038, + 1, 0, 0, 0, 7049, 375, 1, 0, 0, 0, 7050, 7051, 5, 515, 0, 0, 7051, 7052, + 5, 1092, 0, 0, 7052, 7053, 5, 79, 0, 0, 7053, 7054, 5, 82, 0, 0, 7054, + 7055, 5, 1092, 0, 0, 7055, 7056, 3, 852, 426, 0, 7056, 7057, 5, 80, 0, + 0, 7057, 7058, 5, 1092, 0, 0, 7058, 7059, 3, 852, 426, 0, 7059, 7077, 1, + 0, 0, 0, 7060, 7061, 5, 515, 0, 0, 7061, 7062, 5, 1092, 0, 0, 7062, 7063, + 5, 334, 0, 0, 7063, 7064, 5, 336, 0, 0, 7064, 7065, 5, 1092, 0, 0, 7065, + 7077, 3, 852, 426, 0, 7066, 7067, 5, 515, 0, 0, 7067, 7068, 5, 1092, 0, + 0, 7068, 7069, 5, 86, 0, 0, 7069, 7070, 5, 87, 0, 0, 7070, 7071, 5, 1092, + 0, 0, 7071, 7072, 3, 852, 426, 0, 7072, 7073, 5, 91, 0, 0, 7073, 7074, + 5, 1092, 0, 0, 7074, 7075, 3, 852, 426, 0, 7075, 7077, 1, 0, 0, 0, 7076, + 7050, 1, 0, 0, 0, 7076, 7060, 1, 0, 0, 0, 7076, 7066, 1, 0, 0, 0, 7077, + 377, 1, 0, 0, 0, 7078, 7080, 5, 190, 0, 0, 7079, 7081, 3, 654, 327, 0, + 7080, 7079, 1, 0, 0, 0, 7080, 7081, 1, 0, 0, 0, 7081, 7082, 1, 0, 0, 0, + 7082, 7083, 5, 512, 0, 0, 7083, 7085, 5, 394, 0, 0, 7084, 7086, 3, 652, + 326, 0, 7085, 7084, 1, 0, 0, 0, 7085, 7086, 1, 0, 0, 0, 7086, 7087, 1, + 0, 0, 0, 7087, 7088, 3, 856, 428, 0, 7088, 7089, 5, 258, 0, 0, 7089, 7090, + 5, 1092, 0, 0, 7090, 7091, 3, 450, 225, 0, 7091, 7092, 5, 954, 0, 0, 7092, + 7093, 5, 1092, 0, 0, 7093, 7094, 5, 645, 0, 0, 7094, 7096, 3, 374, 187, + 0, 7095, 7097, 3, 646, 323, 0, 7096, 7095, 1, 0, 0, 0, 7096, 7097, 1, 0, + 0, 0, 7097, 7122, 1, 0, 0, 0, 7098, 7100, 5, 190, 0, 0, 7099, 7101, 3, + 654, 327, 0, 7100, 7099, 1, 0, 0, 0, 7100, 7101, 1, 0, 0, 0, 7101, 7102, + 1, 0, 0, 0, 7102, 7103, 5, 512, 0, 0, 7103, 7105, 5, 394, 0, 0, 7104, 7106, + 3, 652, 326, 0, 7105, 7104, 1, 0, 0, 0, 7105, 7106, 1, 0, 0, 0, 7106, 7107, + 1, 0, 0, 0, 7107, 7108, 3, 856, 428, 0, 7108, 7109, 5, 258, 0, 0, 7109, + 7110, 5, 1092, 0, 0, 7110, 7111, 3, 450, 225, 0, 7111, 7112, 5, 237, 0, + 0, 7112, 7113, 5, 1092, 0, 0, 7113, 7114, 5, 570, 0, 0, 7114, 7115, 5, + 954, 0, 0, 7115, 7116, 5, 1092, 0, 0, 7116, 7117, 5, 645, 0, 0, 7117, 7119, + 3, 376, 188, 0, 7118, 7120, 3, 646, 323, 0, 7119, 7118, 1, 0, 0, 0, 7119, + 7120, 1, 0, 0, 0, 7120, 7122, 1, 0, 0, 0, 7121, 7078, 1, 0, 0, 0, 7121, + 7098, 1, 0, 0, 0, 7122, 379, 1, 0, 0, 0, 7123, 7125, 5, 190, 0, 0, 7124, + 7126, 3, 654, 327, 0, 7125, 7124, 1, 0, 0, 0, 7125, 7126, 1, 0, 0, 0, 7126, + 7127, 1, 0, 0, 0, 7127, 7129, 5, 601, 0, 0, 7128, 7130, 3, 652, 326, 0, + 7129, 7128, 1, 0, 0, 0, 7129, 7130, 1, 0, 0, 0, 7130, 7131, 1, 0, 0, 0, + 7131, 7135, 3, 878, 439, 0, 7132, 7133, 5, 69, 0, 0, 7133, 7134, 5, 1092, + 0, 0, 7134, 7136, 3, 450, 225, 0, 7135, 7132, 1, 0, 0, 0, 7135, 7136, 1, + 0, 0, 0, 7136, 7140, 1, 0, 0, 0, 7137, 7138, 5, 274, 0, 0, 7138, 7139, + 5, 1092, 0, 0, 7139, 7141, 3, 856, 428, 0, 7140, 7137, 1, 0, 0, 0, 7140, + 7141, 1, 0, 0, 0, 7141, 7145, 1, 0, 0, 0, 7142, 7143, 5, 81, 0, 0, 7143, + 7144, 5, 1092, 0, 0, 7144, 7146, 3, 852, 426, 0, 7145, 7142, 1, 0, 0, 0, + 7145, 7146, 1, 0, 0, 0, 7146, 7150, 1, 0, 0, 0, 7147, 7148, 5, 394, 0, + 0, 7148, 7149, 5, 1092, 0, 0, 7149, 7151, 3, 852, 426, 0, 7150, 7147, 1, + 0, 0, 0, 7150, 7151, 1, 0, 0, 0, 7151, 7153, 1, 0, 0, 0, 7152, 7154, 3, + 646, 323, 0, 7153, 7152, 1, 0, 0, 0, 7153, 7154, 1, 0, 0, 0, 7154, 7155, + 1, 0, 0, 0, 7155, 7156, 5, 56, 0, 0, 7156, 7157, 3, 38, 19, 0, 7157, 381, + 1, 0, 0, 0, 7158, 7159, 7, 44, 0, 0, 7159, 383, 1, 0, 0, 0, 7160, 7161, + 5, 282, 0, 0, 7161, 7162, 5, 56, 0, 0, 7162, 7163, 3, 382, 191, 0, 7163, + 385, 1, 0, 0, 0, 7164, 7167, 3, 852, 426, 0, 7165, 7167, 5, 1082, 0, 0, + 7166, 7164, 1, 0, 0, 0, 7166, 7165, 1, 0, 0, 0, 7167, 387, 1, 0, 0, 0, + 7168, 7170, 5, 190, 0, 0, 7169, 7171, 3, 654, 327, 0, 7170, 7169, 1, 0, + 0, 0, 7170, 7171, 1, 0, 0, 0, 7171, 7172, 1, 0, 0, 0, 7172, 7173, 5, 628, + 0, 0, 7173, 7174, 3, 878, 439, 0, 7174, 7183, 5, 1104, 0, 0, 7175, 7180, + 3, 354, 177, 0, 7176, 7177, 5, 1110, 0, 0, 7177, 7179, 3, 354, 177, 0, + 7178, 7176, 1, 0, 0, 0, 7179, 7182, 1, 0, 0, 0, 7180, 7178, 1, 0, 0, 0, + 7180, 7181, 1, 0, 0, 0, 7181, 7184, 1, 0, 0, 0, 7182, 7180, 1, 0, 0, 0, + 7183, 7175, 1, 0, 0, 0, 7183, 7184, 1, 0, 0, 0, 7184, 7185, 1, 0, 0, 0, + 7185, 7186, 5, 1105, 0, 0, 7186, 7201, 5, 706, 0, 0, 7187, 7202, 3, 902, + 451, 0, 7188, 7189, 5, 880, 0, 0, 7189, 7198, 5, 1104, 0, 0, 7190, 7195, + 3, 356, 178, 0, 7191, 7192, 5, 1110, 0, 0, 7192, 7194, 3, 356, 178, 0, + 7193, 7191, 1, 0, 0, 0, 7194, 7197, 1, 0, 0, 0, 7195, 7193, 1, 0, 0, 0, + 7195, 7196, 1, 0, 0, 0, 7196, 7199, 1, 0, 0, 0, 7197, 7195, 1, 0, 0, 0, + 7198, 7190, 1, 0, 0, 0, 7198, 7199, 1, 0, 0, 0, 7199, 7200, 1, 0, 0, 0, + 7200, 7202, 5, 1105, 0, 0, 7201, 7187, 1, 0, 0, 0, 7201, 7188, 1, 0, 0, + 0, 7202, 7205, 1, 0, 0, 0, 7203, 7204, 5, 511, 0, 0, 7204, 7206, 5, 522, + 0, 0, 7205, 7203, 1, 0, 0, 0, 7205, 7206, 1, 0, 0, 0, 7206, 7207, 1, 0, + 0, 0, 7207, 7208, 5, 418, 0, 0, 7208, 7219, 5, 820, 0, 0, 7209, 7210, 5, + 114, 0, 0, 7210, 7211, 5, 553, 0, 0, 7211, 7212, 5, 522, 0, 0, 7212, 7220, + 5, 389, 0, 0, 7213, 7214, 5, 706, 0, 0, 7214, 7215, 5, 522, 0, 0, 7215, + 7216, 5, 553, 0, 0, 7216, 7217, 5, 522, 0, 0, 7217, 7220, 5, 389, 0, 0, + 7218, 7220, 5, 859, 0, 0, 7219, 7209, 1, 0, 0, 0, 7219, 7213, 1, 0, 0, + 0, 7219, 7218, 1, 0, 0, 0, 7219, 7220, 1, 0, 0, 0, 7220, 7222, 1, 0, 0, + 0, 7221, 7223, 7, 42, 0, 0, 7222, 7221, 1, 0, 0, 0, 7222, 7223, 1, 0, 0, + 0, 7223, 7225, 1, 0, 0, 0, 7224, 7226, 3, 646, 323, 0, 7225, 7224, 1, 0, + 0, 0, 7225, 7226, 1, 0, 0, 0, 7226, 7228, 1, 0, 0, 0, 7227, 7229, 3, 384, + 192, 0, 7228, 7227, 1, 0, 0, 0, 7228, 7229, 1, 0, 0, 0, 7229, 7230, 1, + 0, 0, 0, 7230, 7231, 5, 56, 0, 0, 7231, 7232, 3, 386, 193, 0, 7232, 7287, + 1, 0, 0, 0, 7233, 7235, 5, 190, 0, 0, 7234, 7236, 3, 654, 327, 0, 7235, + 7234, 1, 0, 0, 0, 7235, 7236, 1, 0, 0, 0, 7236, 7238, 1, 0, 0, 0, 7237, + 7239, 5, 769, 0, 0, 7238, 7237, 1, 0, 0, 0, 7238, 7239, 1, 0, 0, 0, 7239, + 7240, 1, 0, 0, 0, 7240, 7241, 5, 628, 0, 0, 7241, 7242, 3, 878, 439, 0, + 7242, 7251, 5, 1104, 0, 0, 7243, 7248, 3, 354, 177, 0, 7244, 7245, 5, 1110, + 0, 0, 7245, 7247, 3, 354, 177, 0, 7246, 7244, 1, 0, 0, 0, 7247, 7250, 1, + 0, 0, 0, 7248, 7246, 1, 0, 0, 0, 7248, 7249, 1, 0, 0, 0, 7249, 7252, 1, + 0, 0, 0, 7250, 7248, 1, 0, 0, 0, 7251, 7243, 1, 0, 0, 0, 7251, 7252, 1, + 0, 0, 0, 7252, 7253, 1, 0, 0, 0, 7253, 7254, 5, 1105, 0, 0, 7254, 7255, + 5, 706, 0, 0, 7255, 7258, 3, 902, 451, 0, 7256, 7257, 5, 511, 0, 0, 7257, + 7259, 5, 522, 0, 0, 7258, 7256, 1, 0, 0, 0, 7258, 7259, 1, 0, 0, 0, 7259, + 7260, 1, 0, 0, 0, 7260, 7261, 5, 418, 0, 0, 7261, 7272, 5, 402, 0, 0, 7262, + 7263, 5, 114, 0, 0, 7263, 7264, 5, 553, 0, 0, 7264, 7265, 5, 522, 0, 0, + 7265, 7273, 5, 389, 0, 0, 7266, 7267, 5, 706, 0, 0, 7267, 7268, 5, 522, + 0, 0, 7268, 7269, 5, 553, 0, 0, 7269, 7270, 5, 522, 0, 0, 7270, 7273, 5, + 389, 0, 0, 7271, 7273, 5, 859, 0, 0, 7272, 7262, 1, 0, 0, 0, 7272, 7266, + 1, 0, 0, 0, 7272, 7271, 1, 0, 0, 0, 7272, 7273, 1, 0, 0, 0, 7273, 7275, + 1, 0, 0, 0, 7274, 7276, 7, 42, 0, 0, 7275, 7274, 1, 0, 0, 0, 7275, 7276, + 1, 0, 0, 0, 7276, 7278, 1, 0, 0, 0, 7277, 7279, 3, 646, 323, 0, 7278, 7277, + 1, 0, 0, 0, 7278, 7279, 1, 0, 0, 0, 7279, 7281, 1, 0, 0, 0, 7280, 7282, + 3, 384, 192, 0, 7281, 7280, 1, 0, 0, 0, 7281, 7282, 1, 0, 0, 0, 7282, 7283, + 1, 0, 0, 0, 7283, 7284, 5, 56, 0, 0, 7284, 7285, 3, 386, 193, 0, 7285, + 7287, 1, 0, 0, 0, 7286, 7168, 1, 0, 0, 0, 7286, 7233, 1, 0, 0, 0, 7287, + 389, 1, 0, 0, 0, 7288, 7289, 5, 190, 0, 0, 7289, 7290, 5, 687, 0, 0, 7290, + 7292, 5, 350, 0, 0, 7291, 7293, 3, 652, 326, 0, 7292, 7291, 1, 0, 0, 0, + 7292, 7293, 1, 0, 0, 0, 7293, 7294, 1, 0, 0, 0, 7294, 7295, 3, 856, 428, + 0, 7295, 7296, 5, 541, 0, 0, 7296, 7297, 5, 1092, 0, 0, 7297, 7302, 3, + 836, 418, 0, 7298, 7299, 5, 1110, 0, 0, 7299, 7301, 3, 836, 418, 0, 7300, + 7298, 1, 0, 0, 0, 7301, 7304, 1, 0, 0, 0, 7302, 7300, 1, 0, 0, 0, 7302, + 7303, 1, 0, 0, 0, 7303, 7315, 1, 0, 0, 0, 7304, 7302, 1, 0, 0, 0, 7305, + 7306, 5, 26, 0, 0, 7306, 7307, 5, 1092, 0, 0, 7307, 7312, 3, 856, 428, + 0, 7308, 7309, 5, 1110, 0, 0, 7309, 7311, 3, 856, 428, 0, 7310, 7308, 1, + 0, 0, 0, 7311, 7314, 1, 0, 0, 0, 7312, 7310, 1, 0, 0, 0, 7312, 7313, 1, + 0, 0, 0, 7313, 7316, 1, 0, 0, 0, 7314, 7312, 1, 0, 0, 0, 7315, 7305, 1, + 0, 0, 0, 7315, 7316, 1, 0, 0, 0, 7316, 7327, 1, 0, 0, 0, 7317, 7318, 5, + 29, 0, 0, 7318, 7319, 5, 1092, 0, 0, 7319, 7324, 3, 856, 428, 0, 7320, + 7321, 5, 1110, 0, 0, 7321, 7323, 3, 856, 428, 0, 7322, 7320, 1, 0, 0, 0, + 7323, 7326, 1, 0, 0, 0, 7324, 7322, 1, 0, 0, 0, 7324, 7325, 1, 0, 0, 0, + 7325, 7328, 1, 0, 0, 0, 7326, 7324, 1, 0, 0, 0, 7327, 7317, 1, 0, 0, 0, + 7327, 7328, 1, 0, 0, 0, 7328, 7339, 1, 0, 0, 0, 7329, 7330, 5, 27, 0, 0, + 7330, 7331, 5, 1092, 0, 0, 7331, 7336, 3, 346, 173, 0, 7332, 7333, 5, 1110, + 0, 0, 7333, 7335, 3, 346, 173, 0, 7334, 7332, 1, 0, 0, 0, 7335, 7338, 1, + 0, 0, 0, 7336, 7334, 1, 0, 0, 0, 7336, 7337, 1, 0, 0, 0, 7337, 7340, 1, + 0, 0, 0, 7338, 7336, 1, 0, 0, 0, 7339, 7329, 1, 0, 0, 0, 7339, 7340, 1, + 0, 0, 0, 7340, 7341, 1, 0, 0, 0, 7341, 7342, 5, 25, 0, 0, 7342, 7343, 5, + 1092, 0, 0, 7343, 7348, 3, 344, 172, 0, 7344, 7345, 5, 1110, 0, 0, 7345, + 7347, 3, 344, 172, 0, 7346, 7344, 1, 0, 0, 0, 7347, 7350, 1, 0, 0, 0, 7348, + 7346, 1, 0, 0, 0, 7348, 7349, 1, 0, 0, 0, 7349, 7354, 1, 0, 0, 0, 7350, + 7348, 1, 0, 0, 0, 7351, 7352, 5, 367, 0, 0, 7352, 7353, 5, 252, 0, 0, 7353, + 7355, 5, 131, 0, 0, 7354, 7351, 1, 0, 0, 0, 7354, 7355, 1, 0, 0, 0, 7355, + 7359, 1, 0, 0, 0, 7356, 7357, 5, 688, 0, 0, 7357, 7358, 5, 1092, 0, 0, + 7358, 7360, 3, 852, 426, 0, 7359, 7356, 1, 0, 0, 0, 7359, 7360, 1, 0, 0, + 0, 7360, 7378, 1, 0, 0, 0, 7361, 7362, 5, 190, 0, 0, 7362, 7363, 5, 687, + 0, 0, 7363, 7365, 5, 350, 0, 0, 7364, 7366, 3, 652, 326, 0, 7365, 7364, + 1, 0, 0, 0, 7365, 7366, 1, 0, 0, 0, 7366, 7367, 1, 0, 0, 0, 7367, 7368, + 3, 856, 428, 0, 7368, 7369, 5, 56, 0, 0, 7369, 7370, 5, 686, 0, 0, 7370, + 7371, 5, 542, 0, 0, 7371, 7372, 3, 856, 428, 0, 7372, 7373, 5, 1099, 0, + 0, 7373, 7374, 3, 856, 428, 0, 7374, 7375, 5, 1099, 0, 0, 7375, 7376, 3, + 856, 428, 0, 7376, 7378, 1, 0, 0, 0, 7377, 7288, 1, 0, 0, 0, 7377, 7361, + 1, 0, 0, 0, 7378, 391, 1, 0, 0, 0, 7379, 7381, 5, 190, 0, 0, 7380, 7382, + 3, 654, 327, 0, 7381, 7380, 1, 0, 0, 0, 7381, 7382, 1, 0, 0, 0, 7382, 7383, + 1, 0, 0, 0, 7383, 7384, 5, 694, 0, 0, 7384, 7385, 5, 484, 0, 0, 7385, 7386, + 3, 856, 428, 0, 7386, 7388, 5, 1020, 0, 0, 7387, 7389, 3, 198, 99, 0, 7388, + 7387, 1, 0, 0, 0, 7388, 7389, 1, 0, 0, 0, 7389, 7391, 1, 0, 0, 0, 7390, + 7392, 3, 200, 100, 0, 7391, 7390, 1, 0, 0, 0, 7391, 7392, 1, 0, 0, 0, 7392, + 7399, 1, 0, 0, 0, 7393, 7394, 5, 832, 0, 0, 7394, 7397, 5, 1092, 0, 0, + 7395, 7398, 3, 852, 426, 0, 7396, 7398, 5, 375, 0, 0, 7397, 7395, 1, 0, + 0, 0, 7397, 7396, 1, 0, 0, 0, 7398, 7400, 1, 0, 0, 0, 7399, 7393, 1, 0, + 0, 0, 7399, 7400, 1, 0, 0, 0, 7400, 7404, 1, 0, 0, 0, 7401, 7402, 5, 268, + 0, 0, 7402, 7403, 5, 1092, 0, 0, 7403, 7405, 3, 852, 426, 0, 7404, 7401, + 1, 0, 0, 0, 7404, 7405, 1, 0, 0, 0, 7405, 7407, 1, 0, 0, 0, 7406, 7408, + 3, 202, 101, 0, 7407, 7406, 1, 0, 0, 0, 7407, 7408, 1, 0, 0, 0, 7408, 7415, + 1, 0, 0, 0, 7409, 7411, 5, 939, 0, 0, 7410, 7412, 3, 546, 273, 0, 7411, + 7410, 1, 0, 0, 0, 7412, 7413, 1, 0, 0, 0, 7413, 7411, 1, 0, 0, 0, 7413, + 7414, 1, 0, 0, 0, 7414, 7416, 1, 0, 0, 0, 7415, 7409, 1, 0, 0, 0, 7415, + 7416, 1, 0, 0, 0, 7416, 393, 1, 0, 0, 0, 7417, 7419, 5, 190, 0, 0, 7418, + 7420, 3, 654, 327, 0, 7419, 7418, 1, 0, 0, 0, 7419, 7420, 1, 0, 0, 0, 7420, + 7421, 1, 0, 0, 0, 7421, 7423, 5, 718, 0, 0, 7422, 7424, 3, 652, 326, 0, + 7423, 7422, 1, 0, 0, 0, 7423, 7424, 1, 0, 0, 0, 7424, 7425, 1, 0, 0, 0, + 7425, 7446, 3, 856, 428, 0, 7426, 7428, 5, 1020, 0, 0, 7427, 7426, 1, 0, + 0, 0, 7427, 7428, 1, 0, 0, 0, 7428, 7429, 1, 0, 0, 0, 7429, 7430, 5, 887, + 0, 0, 7430, 7431, 5, 1104, 0, 0, 7431, 7432, 3, 856, 428, 0, 7432, 7433, + 5, 1092, 0, 0, 7433, 7441, 5, 1083, 0, 0, 7434, 7435, 5, 1110, 0, 0, 7435, + 7436, 3, 856, 428, 0, 7436, 7437, 5, 1092, 0, 0, 7437, 7438, 5, 1083, 0, + 0, 7438, 7440, 1, 0, 0, 0, 7439, 7434, 1, 0, 0, 0, 7440, 7443, 1, 0, 0, + 0, 7441, 7439, 1, 0, 0, 0, 7441, 7442, 1, 0, 0, 0, 7442, 7444, 1, 0, 0, + 0, 7443, 7441, 1, 0, 0, 0, 7444, 7445, 5, 1105, 0, 0, 7445, 7447, 1, 0, + 0, 0, 7446, 7427, 1, 0, 0, 0, 7446, 7447, 1, 0, 0, 0, 7447, 7451, 1, 0, + 0, 0, 7448, 7449, 5, 161, 0, 0, 7449, 7450, 5, 1092, 0, 0, 7450, 7452, + 5, 1083, 0, 0, 7451, 7448, 1, 0, 0, 0, 7451, 7452, 1, 0, 0, 0, 7452, 395, + 1, 0, 0, 0, 7453, 7455, 5, 190, 0, 0, 7454, 7456, 3, 654, 327, 0, 7455, + 7454, 1, 0, 0, 0, 7455, 7456, 1, 0, 0, 0, 7456, 7457, 1, 0, 0, 0, 7457, + 7458, 5, 723, 0, 0, 7458, 7459, 5, 8, 0, 0, 7459, 7461, 5, 608, 0, 0, 7460, + 7462, 3, 652, 326, 0, 7461, 7460, 1, 0, 0, 0, 7461, 7462, 1, 0, 0, 0, 7462, + 7463, 1, 0, 0, 0, 7463, 7464, 3, 856, 428, 0, 7464, 7465, 5, 56, 0, 0, + 7465, 7466, 5, 1104, 0, 0, 7466, 7471, 3, 354, 177, 0, 7467, 7468, 5, 1110, + 0, 0, 7468, 7470, 3, 354, 177, 0, 7469, 7467, 1, 0, 0, 0, 7470, 7473, 1, + 0, 0, 0, 7471, 7469, 1, 0, 0, 0, 7471, 7472, 1, 0, 0, 0, 7472, 7474, 1, + 0, 0, 0, 7473, 7471, 1, 0, 0, 0, 7474, 7475, 5, 1105, 0, 0, 7475, 7476, + 5, 706, 0, 0, 7476, 7477, 5, 1043, 0, 0, 7477, 7478, 5, 1088, 0, 0, 7478, + 7480, 3, 886, 443, 0, 7479, 7481, 3, 646, 323, 0, 7480, 7479, 1, 0, 0, + 0, 7480, 7481, 1, 0, 0, 0, 7481, 397, 1, 0, 0, 0, 7482, 7484, 5, 190, 0, + 0, 7483, 7485, 3, 654, 327, 0, 7484, 7483, 1, 0, 0, 0, 7484, 7485, 1, 0, + 0, 0, 7485, 7487, 1, 0, 0, 0, 7486, 7488, 5, 936, 0, 0, 7487, 7486, 1, + 0, 0, 0, 7487, 7488, 1, 0, 0, 0, 7488, 7489, 1, 0, 0, 0, 7489, 7491, 5, + 757, 0, 0, 7490, 7492, 3, 652, 326, 0, 7491, 7490, 1, 0, 0, 0, 7491, 7492, + 1, 0, 0, 0, 7492, 7493, 1, 0, 0, 0, 7493, 7495, 3, 834, 417, 0, 7494, 7496, + 3, 326, 163, 0, 7495, 7494, 1, 0, 0, 0, 7495, 7496, 1, 0, 0, 0, 7496, 7500, + 1, 0, 0, 0, 7497, 7498, 5, 1020, 0, 0, 7498, 7499, 5, 452, 0, 0, 7499, + 7501, 5, 8, 0, 0, 7500, 7497, 1, 0, 0, 0, 7500, 7501, 1, 0, 0, 0, 7501, + 7505, 1, 0, 0, 0, 7502, 7503, 5, 209, 0, 0, 7503, 7504, 5, 1092, 0, 0, + 7504, 7506, 3, 880, 440, 0, 7505, 7502, 1, 0, 0, 0, 7505, 7506, 1, 0, 0, + 0, 7506, 7510, 1, 0, 0, 0, 7507, 7508, 5, 467, 0, 0, 7508, 7509, 5, 1092, + 0, 0, 7509, 7511, 3, 880, 440, 0, 7510, 7507, 1, 0, 0, 0, 7510, 7511, 1, + 0, 0, 0, 7511, 7513, 1, 0, 0, 0, 7512, 7514, 3, 130, 65, 0, 7513, 7512, + 1, 0, 0, 0, 7513, 7514, 1, 0, 0, 0, 7514, 7516, 1, 0, 0, 0, 7515, 7517, + 3, 488, 244, 0, 7516, 7515, 1, 0, 0, 0, 7516, 7517, 1, 0, 0, 0, 7517, 7519, + 1, 0, 0, 0, 7518, 7520, 3, 646, 323, 0, 7519, 7518, 1, 0, 0, 0, 7519, 7520, + 1, 0, 0, 0, 7520, 399, 1, 0, 0, 0, 7521, 7523, 5, 190, 0, 0, 7522, 7524, + 3, 654, 327, 0, 7523, 7522, 1, 0, 0, 0, 7523, 7524, 1, 0, 0, 0, 7524, 7525, + 1, 0, 0, 0, 7525, 7526, 5, 770, 0, 0, 7526, 7528, 5, 394, 0, 0, 7527, 7529, + 3, 652, 326, 0, 7528, 7527, 1, 0, 0, 0, 7528, 7529, 1, 0, 0, 0, 7529, 7530, + 1, 0, 0, 0, 7530, 7531, 3, 856, 428, 0, 7531, 7532, 5, 954, 0, 0, 7532, + 7533, 5, 1092, 0, 0, 7533, 7534, 5, 292, 0, 0, 7534, 7535, 5, 258, 0, 0, + 7535, 7536, 5, 1092, 0, 0, 7536, 7537, 3, 450, 225, 0, 7537, 7538, 5, 305, + 0, 0, 7538, 7539, 5, 1092, 0, 0, 7539, 7540, 7, 22, 0, 0, 7540, 7541, 5, + 298, 0, 0, 7541, 7542, 5, 1092, 0, 0, 7542, 7543, 3, 852, 426, 0, 7543, + 7544, 5, 304, 0, 0, 7544, 7550, 5, 1092, 0, 0, 7545, 7551, 3, 852, 426, + 0, 7546, 7547, 5, 1104, 0, 0, 7547, 7548, 3, 854, 427, 0, 7548, 7549, 5, + 1105, 0, 0, 7549, 7551, 1, 0, 0, 0, 7550, 7545, 1, 0, 0, 0, 7550, 7546, + 1, 0, 0, 0, 7551, 7552, 1, 0, 0, 0, 7552, 7553, 5, 303, 0, 0, 7553, 7554, + 5, 1092, 0, 0, 7554, 7558, 3, 852, 426, 0, 7555, 7556, 5, 299, 0, 0, 7556, + 7557, 5, 1092, 0, 0, 7557, 7559, 3, 852, 426, 0, 7558, 7555, 1, 0, 0, 0, + 7558, 7559, 1, 0, 0, 0, 7559, 7569, 1, 0, 0, 0, 7560, 7561, 5, 299, 0, + 0, 7561, 7567, 5, 1092, 0, 0, 7562, 7568, 3, 852, 426, 0, 7563, 7564, 5, + 1104, 0, 0, 7564, 7565, 3, 854, 427, 0, 7565, 7566, 5, 1105, 0, 0, 7566, + 7568, 1, 0, 0, 0, 7567, 7562, 1, 0, 0, 0, 7567, 7563, 1, 0, 0, 0, 7568, + 7570, 1, 0, 0, 0, 7569, 7560, 1, 0, 0, 0, 7569, 7570, 1, 0, 0, 0, 7570, + 7577, 1, 0, 0, 0, 7571, 7572, 5, 297, 0, 0, 7572, 7573, 5, 1092, 0, 0, + 7573, 7574, 5, 1104, 0, 0, 7574, 7575, 3, 854, 427, 0, 7575, 7576, 5, 1105, + 0, 0, 7576, 7578, 1, 0, 0, 0, 7577, 7571, 1, 0, 0, 0, 7577, 7578, 1, 0, + 0, 0, 7578, 7585, 1, 0, 0, 0, 7579, 7580, 5, 294, 0, 0, 7580, 7581, 5, + 1092, 0, 0, 7581, 7582, 5, 1104, 0, 0, 7582, 7583, 3, 854, 427, 0, 7583, + 7584, 5, 1105, 0, 0, 7584, 7586, 1, 0, 0, 0, 7585, 7579, 1, 0, 0, 0, 7585, + 7586, 1, 0, 0, 0, 7586, 7590, 1, 0, 0, 0, 7587, 7588, 5, 300, 0, 0, 7588, + 7589, 5, 1092, 0, 0, 7589, 7591, 3, 852, 426, 0, 7590, 7587, 1, 0, 0, 0, + 7590, 7591, 1, 0, 0, 0, 7591, 7595, 1, 0, 0, 0, 7592, 7593, 5, 301, 0, + 0, 7593, 7594, 5, 1092, 0, 0, 7594, 7596, 3, 852, 426, 0, 7595, 7592, 1, + 0, 0, 0, 7595, 7596, 1, 0, 0, 0, 7596, 7603, 1, 0, 0, 0, 7597, 7598, 5, + 296, 0, 0, 7598, 7599, 5, 1092, 0, 0, 7599, 7600, 5, 1104, 0, 0, 7600, + 7601, 3, 852, 426, 0, 7601, 7602, 5, 1105, 0, 0, 7602, 7604, 1, 0, 0, 0, + 7603, 7597, 1, 0, 0, 0, 7603, 7604, 1, 0, 0, 0, 7604, 7608, 1, 0, 0, 0, + 7605, 7606, 5, 295, 0, 0, 7606, 7607, 5, 1092, 0, 0, 7607, 7609, 7, 23, + 0, 0, 7608, 7605, 1, 0, 0, 0, 7608, 7609, 1, 0, 0, 0, 7609, 7613, 1, 0, + 0, 0, 7610, 7611, 5, 302, 0, 0, 7611, 7612, 5, 1092, 0, 0, 7612, 7614, + 3, 852, 426, 0, 7613, 7610, 1, 0, 0, 0, 7613, 7614, 1, 0, 0, 0, 7614, 401, + 1, 0, 0, 0, 7615, 7616, 7, 24, 0, 0, 7616, 403, 1, 0, 0, 0, 7617, 7619, + 5, 190, 0, 0, 7618, 7620, 3, 654, 327, 0, 7619, 7618, 1, 0, 0, 0, 7619, + 7620, 1, 0, 0, 0, 7620, 7621, 1, 0, 0, 0, 7621, 7622, 5, 770, 0, 0, 7622, + 7624, 5, 394, 0, 0, 7623, 7625, 3, 652, 326, 0, 7624, 7623, 1, 0, 0, 0, + 7624, 7625, 1, 0, 0, 0, 7625, 7626, 1, 0, 0, 0, 7626, 7627, 3, 856, 428, + 0, 7627, 7628, 5, 954, 0, 0, 7628, 7629, 5, 1092, 0, 0, 7629, 7630, 5, + 528, 0, 0, 7630, 7631, 5, 530, 0, 0, 7631, 7632, 5, 1092, 0, 0, 7632, 7633, + 3, 412, 206, 0, 7633, 7634, 5, 535, 0, 0, 7634, 7635, 5, 1092, 0, 0, 7635, + 7637, 3, 852, 426, 0, 7636, 7638, 3, 138, 69, 0, 7637, 7636, 1, 0, 0, 0, + 7637, 7638, 1, 0, 0, 0, 7638, 7642, 1, 0, 0, 0, 7639, 7640, 5, 534, 0, + 0, 7640, 7641, 5, 1092, 0, 0, 7641, 7643, 3, 450, 225, 0, 7642, 7639, 1, + 0, 0, 0, 7642, 7643, 1, 0, 0, 0, 7643, 7647, 1, 0, 0, 0, 7644, 7645, 5, + 536, 0, 0, 7645, 7646, 5, 1092, 0, 0, 7646, 7648, 3, 880, 440, 0, 7647, + 7644, 1, 0, 0, 0, 7647, 7648, 1, 0, 0, 0, 7648, 7652, 1, 0, 0, 0, 7649, + 7650, 5, 537, 0, 0, 7650, 7651, 5, 1092, 0, 0, 7651, 7653, 3, 402, 201, + 0, 7652, 7649, 1, 0, 0, 0, 7652, 7653, 1, 0, 0, 0, 7653, 7660, 1, 0, 0, + 0, 7654, 7655, 5, 105, 0, 0, 7655, 7656, 5, 1092, 0, 0, 7656, 7657, 5, + 1104, 0, 0, 7657, 7658, 3, 854, 427, 0, 7658, 7659, 5, 1105, 0, 0, 7659, + 7661, 1, 0, 0, 0, 7660, 7654, 1, 0, 0, 0, 7660, 7661, 1, 0, 0, 0, 7661, + 7663, 1, 0, 0, 0, 7662, 7664, 3, 646, 323, 0, 7663, 7662, 1, 0, 0, 0, 7663, + 7664, 1, 0, 0, 0, 7664, 7745, 1, 0, 0, 0, 7665, 7667, 5, 190, 0, 0, 7666, + 7668, 3, 654, 327, 0, 7667, 7666, 1, 0, 0, 0, 7667, 7668, 1, 0, 0, 0, 7668, + 7669, 1, 0, 0, 0, 7669, 7670, 5, 770, 0, 0, 7670, 7672, 5, 394, 0, 0, 7671, + 7673, 3, 652, 326, 0, 7672, 7671, 1, 0, 0, 0, 7672, 7673, 1, 0, 0, 0, 7673, + 7674, 1, 0, 0, 0, 7674, 7675, 3, 856, 428, 0, 7675, 7676, 5, 954, 0, 0, + 7676, 7677, 5, 1092, 0, 0, 7677, 7678, 5, 528, 0, 0, 7678, 7679, 5, 530, + 0, 0, 7679, 7680, 5, 1092, 0, 0, 7680, 7681, 5, 204, 0, 0, 7681, 7682, + 5, 535, 0, 0, 7682, 7683, 5, 1092, 0, 0, 7683, 7685, 3, 852, 426, 0, 7684, + 7686, 3, 138, 69, 0, 7685, 7684, 1, 0, 0, 0, 7685, 7686, 1, 0, 0, 0, 7686, + 7690, 1, 0, 0, 0, 7687, 7688, 5, 529, 0, 0, 7688, 7689, 5, 1092, 0, 0, + 7689, 7691, 3, 450, 225, 0, 7690, 7687, 1, 0, 0, 0, 7690, 7691, 1, 0, 0, + 0, 7691, 7695, 1, 0, 0, 0, 7692, 7693, 5, 533, 0, 0, 7693, 7694, 5, 1092, + 0, 0, 7694, 7696, 3, 450, 225, 0, 7695, 7692, 1, 0, 0, 0, 7695, 7696, 1, + 0, 0, 0, 7696, 7700, 1, 0, 0, 0, 7697, 7698, 5, 537, 0, 0, 7698, 7699, + 5, 1092, 0, 0, 7699, 7701, 3, 402, 201, 0, 7700, 7697, 1, 0, 0, 0, 7700, + 7701, 1, 0, 0, 0, 7701, 7708, 1, 0, 0, 0, 7702, 7703, 5, 618, 0, 0, 7703, + 7704, 5, 1092, 0, 0, 7704, 7705, 5, 1104, 0, 0, 7705, 7706, 3, 854, 427, + 0, 7706, 7707, 5, 1105, 0, 0, 7707, 7709, 1, 0, 0, 0, 7708, 7702, 1, 0, + 0, 0, 7708, 7709, 1, 0, 0, 0, 7709, 7716, 1, 0, 0, 0, 7710, 7711, 5, 105, + 0, 0, 7711, 7712, 5, 1092, 0, 0, 7712, 7713, 5, 1104, 0, 0, 7713, 7714, + 3, 854, 427, 0, 7714, 7715, 5, 1105, 0, 0, 7715, 7717, 1, 0, 0, 0, 7716, + 7710, 1, 0, 0, 0, 7716, 7717, 1, 0, 0, 0, 7717, 7721, 1, 0, 0, 0, 7718, + 7719, 5, 534, 0, 0, 7719, 7720, 5, 1092, 0, 0, 7720, 7722, 3, 450, 225, + 0, 7721, 7718, 1, 0, 0, 0, 7721, 7722, 1, 0, 0, 0, 7722, 7726, 1, 0, 0, + 0, 7723, 7724, 5, 536, 0, 0, 7724, 7725, 5, 1092, 0, 0, 7725, 7727, 3, + 880, 440, 0, 7726, 7723, 1, 0, 0, 0, 7726, 7727, 1, 0, 0, 0, 7727, 7729, + 1, 0, 0, 0, 7728, 7730, 3, 410, 205, 0, 7729, 7728, 1, 0, 0, 0, 7729, 7730, + 1, 0, 0, 0, 7730, 7734, 1, 0, 0, 0, 7731, 7732, 5, 531, 0, 0, 7732, 7733, + 5, 1092, 0, 0, 7733, 7735, 3, 852, 426, 0, 7734, 7731, 1, 0, 0, 0, 7734, + 7735, 1, 0, 0, 0, 7735, 7739, 1, 0, 0, 0, 7736, 7737, 5, 532, 0, 0, 7737, + 7738, 5, 1092, 0, 0, 7738, 7740, 3, 852, 426, 0, 7739, 7736, 1, 0, 0, 0, + 7739, 7740, 1, 0, 0, 0, 7740, 7742, 1, 0, 0, 0, 7741, 7743, 3, 646, 323, + 0, 7742, 7741, 1, 0, 0, 0, 7742, 7743, 1, 0, 0, 0, 7743, 7745, 1, 0, 0, + 0, 7744, 7617, 1, 0, 0, 0, 7744, 7665, 1, 0, 0, 0, 7745, 405, 1, 0, 0, + 0, 7746, 7748, 5, 190, 0, 0, 7747, 7749, 3, 654, 327, 0, 7748, 7747, 1, + 0, 0, 0, 7748, 7749, 1, 0, 0, 0, 7749, 7750, 1, 0, 0, 0, 7750, 7751, 5, + 770, 0, 0, 7751, 7753, 5, 394, 0, 0, 7752, 7754, 3, 652, 326, 0, 7753, + 7752, 1, 0, 0, 0, 7753, 7754, 1, 0, 0, 0, 7754, 7755, 1, 0, 0, 0, 7755, + 7756, 5, 954, 0, 0, 7756, 7757, 5, 1092, 0, 0, 7757, 7758, 5, 737, 0, 0, + 7758, 7759, 3, 138, 69, 0, 7759, 7760, 5, 740, 0, 0, 7760, 7761, 5, 1092, + 0, 0, 7761, 7762, 3, 852, 426, 0, 7762, 7763, 5, 749, 0, 0, 7763, 7764, + 5, 1092, 0, 0, 7764, 7765, 3, 852, 426, 0, 7765, 7766, 5, 742, 0, 0, 7766, + 7767, 5, 1092, 0, 0, 7767, 7768, 3, 852, 426, 0, 7768, 7769, 5, 750, 0, + 0, 7769, 7770, 5, 1092, 0, 0, 7770, 7774, 3, 852, 426, 0, 7771, 7772, 5, + 748, 0, 0, 7772, 7773, 5, 1092, 0, 0, 7773, 7775, 3, 852, 426, 0, 7774, + 7771, 1, 0, 0, 0, 7774, 7775, 1, 0, 0, 0, 7775, 7779, 1, 0, 0, 0, 7776, + 7777, 5, 738, 0, 0, 7777, 7778, 5, 1092, 0, 0, 7778, 7780, 3, 450, 225, + 0, 7779, 7776, 1, 0, 0, 0, 7779, 7780, 1, 0, 0, 0, 7780, 7784, 1, 0, 0, + 0, 7781, 7782, 5, 747, 0, 0, 7782, 7783, 5, 1092, 0, 0, 7783, 7785, 3, + 852, 426, 0, 7784, 7781, 1, 0, 0, 0, 7784, 7785, 1, 0, 0, 0, 7785, 7789, + 1, 0, 0, 0, 7786, 7787, 5, 744, 0, 0, 7787, 7788, 5, 1092, 0, 0, 7788, + 7790, 3, 450, 225, 0, 7789, 7786, 1, 0, 0, 0, 7789, 7790, 1, 0, 0, 0, 7790, + 7794, 1, 0, 0, 0, 7791, 7792, 5, 743, 0, 0, 7792, 7793, 5, 1092, 0, 0, + 7793, 7795, 3, 852, 426, 0, 7794, 7791, 1, 0, 0, 0, 7794, 7795, 1, 0, 0, + 0, 7795, 7799, 1, 0, 0, 0, 7796, 7797, 5, 741, 0, 0, 7797, 7798, 5, 1092, + 0, 0, 7798, 7800, 3, 852, 426, 0, 7799, 7796, 1, 0, 0, 0, 7799, 7800, 1, + 0, 0, 0, 7800, 7804, 1, 0, 0, 0, 7801, 7802, 5, 739, 0, 0, 7802, 7803, + 5, 1092, 0, 0, 7803, 7805, 3, 450, 225, 0, 7804, 7801, 1, 0, 0, 0, 7804, + 7805, 1, 0, 0, 0, 7805, 7809, 1, 0, 0, 0, 7806, 7807, 5, 746, 0, 0, 7807, + 7808, 5, 1092, 0, 0, 7808, 7810, 3, 852, 426, 0, 7809, 7806, 1, 0, 0, 0, + 7809, 7810, 1, 0, 0, 0, 7810, 7814, 1, 0, 0, 0, 7811, 7812, 5, 745, 0, + 0, 7812, 7813, 5, 1092, 0, 0, 7813, 7815, 3, 852, 426, 0, 7814, 7811, 1, + 0, 0, 0, 7814, 7815, 1, 0, 0, 0, 7815, 407, 1, 0, 0, 0, 7816, 7818, 5, + 190, 0, 0, 7817, 7819, 3, 654, 327, 0, 7818, 7817, 1, 0, 0, 0, 7818, 7819, + 1, 0, 0, 0, 7819, 7820, 1, 0, 0, 0, 7820, 7821, 5, 770, 0, 0, 7821, 7823, + 5, 394, 0, 0, 7822, 7824, 3, 652, 326, 0, 7823, 7822, 1, 0, 0, 0, 7823, + 7824, 1, 0, 0, 0, 7824, 7825, 1, 0, 0, 0, 7825, 7826, 3, 856, 428, 0, 7826, + 7827, 5, 954, 0, 0, 7827, 7828, 5, 1092, 0, 0, 7828, 7829, 5, 760, 0, 0, + 7829, 7830, 5, 761, 0, 0, 7830, 7831, 5, 1092, 0, 0, 7831, 7832, 7, 45, + 0, 0, 7832, 7833, 5, 733, 0, 0, 7833, 7834, 5, 1092, 0, 0, 7834, 7836, + 7, 46, 0, 0, 7835, 7837, 3, 410, 205, 0, 7836, 7835, 1, 0, 0, 0, 7836, + 7837, 1, 0, 0, 0, 7837, 7841, 1, 0, 0, 0, 7838, 7839, 5, 876, 0, 0, 7839, + 7840, 5, 1092, 0, 0, 7840, 7842, 3, 450, 225, 0, 7841, 7838, 1, 0, 0, 0, + 7841, 7842, 1, 0, 0, 0, 7842, 7844, 1, 0, 0, 0, 7843, 7845, 3, 646, 323, + 0, 7844, 7843, 1, 0, 0, 0, 7844, 7845, 1, 0, 0, 0, 7845, 409, 1, 0, 0, + 0, 7846, 7847, 5, 497, 0, 0, 7847, 7848, 5, 1092, 0, 0, 7848, 7849, 3, + 852, 426, 0, 7849, 411, 1, 0, 0, 0, 7850, 7851, 7, 47, 0, 0, 7851, 413, + 1, 0, 0, 0, 7852, 7854, 5, 828, 0, 0, 7853, 7855, 5, 1020, 0, 0, 7854, + 7853, 1, 0, 0, 0, 7854, 7855, 1, 0, 0, 0, 7855, 7857, 1, 0, 0, 0, 7856, + 7858, 5, 1092, 0, 0, 7857, 7856, 1, 0, 0, 0, 7857, 7858, 1, 0, 0, 0, 7858, + 7859, 1, 0, 0, 0, 7859, 7860, 3, 880, 440, 0, 7860, 415, 1, 0, 0, 0, 7861, + 7863, 5, 381, 0, 0, 7862, 7864, 5, 110, 0, 0, 7863, 7862, 1, 0, 0, 0, 7863, + 7864, 1, 0, 0, 0, 7864, 7866, 1, 0, 0, 0, 7865, 7867, 5, 1092, 0, 0, 7866, + 7865, 1, 0, 0, 0, 7866, 7867, 1, 0, 0, 0, 7867, 7868, 1, 0, 0, 0, 7868, + 7869, 3, 880, 440, 0, 7869, 417, 1, 0, 0, 0, 7870, 7872, 5, 190, 0, 0, + 7871, 7873, 3, 654, 327, 0, 7872, 7871, 1, 0, 0, 0, 7872, 7873, 1, 0, 0, + 0, 7873, 7874, 1, 0, 0, 0, 7874, 7876, 5, 775, 0, 0, 7875, 7877, 3, 652, + 326, 0, 7876, 7875, 1, 0, 0, 0, 7876, 7877, 1, 0, 0, 0, 7877, 7878, 1, + 0, 0, 0, 7878, 7880, 3, 878, 439, 0, 7879, 7881, 5, 1020, 0, 0, 7880, 7879, + 1, 0, 0, 0, 7880, 7881, 1, 0, 0, 0, 7881, 7883, 1, 0, 0, 0, 7882, 7884, + 3, 414, 207, 0, 7883, 7882, 1, 0, 0, 0, 7883, 7884, 1, 0, 0, 0, 7884, 7886, + 1, 0, 0, 0, 7885, 7887, 3, 416, 208, 0, 7886, 7885, 1, 0, 0, 0, 7886, 7887, + 1, 0, 0, 0, 7887, 7889, 1, 0, 0, 0, 7888, 7890, 3, 646, 323, 0, 7889, 7888, + 1, 0, 0, 0, 7889, 7890, 1, 0, 0, 0, 7890, 419, 1, 0, 0, 0, 7891, 7893, + 5, 190, 0, 0, 7892, 7894, 3, 654, 327, 0, 7893, 7892, 1, 0, 0, 0, 7893, + 7894, 1, 0, 0, 0, 7894, 7895, 1, 0, 0, 0, 7895, 7896, 5, 779, 0, 0, 7896, + 7898, 5, 608, 0, 0, 7897, 7899, 3, 650, 325, 0, 7898, 7897, 1, 0, 0, 0, + 7898, 7899, 1, 0, 0, 0, 7899, 7900, 1, 0, 0, 0, 7900, 7904, 3, 856, 428, + 0, 7901, 7902, 5, 780, 0, 0, 7902, 7903, 5, 1092, 0, 0, 7903, 7905, 3, + 880, 440, 0, 7904, 7901, 1, 0, 0, 0, 7904, 7905, 1, 0, 0, 0, 7905, 7909, + 1, 0, 0, 0, 7906, 7907, 5, 782, 0, 0, 7907, 7908, 5, 1092, 0, 0, 7908, + 7910, 3, 880, 440, 0, 7909, 7906, 1, 0, 0, 0, 7909, 7910, 1, 0, 0, 0, 7910, + 7912, 1, 0, 0, 0, 7911, 7913, 3, 646, 323, 0, 7912, 7911, 1, 0, 0, 0, 7912, + 7913, 1, 0, 0, 0, 7913, 421, 1, 0, 0, 0, 7914, 7916, 5, 190, 0, 0, 7915, + 7917, 3, 654, 327, 0, 7916, 7915, 1, 0, 0, 0, 7916, 7917, 1, 0, 0, 0, 7917, + 7918, 1, 0, 0, 0, 7918, 7919, 5, 786, 0, 0, 7919, 7921, 3, 856, 428, 0, + 7920, 7922, 3, 646, 323, 0, 7921, 7920, 1, 0, 0, 0, 7921, 7922, 1, 0, 0, + 0, 7922, 423, 1, 0, 0, 0, 7923, 7924, 5, 1087, 0, 0, 7924, 425, 1, 0, 0, + 0, 7925, 7926, 5, 165, 0, 0, 7926, 7927, 5, 1092, 0, 0, 7927, 8068, 7, + 48, 0, 0, 7928, 7929, 5, 665, 0, 0, 7929, 7932, 5, 1092, 0, 0, 7930, 7933, + 3, 852, 426, 0, 7931, 7933, 5, 508, 0, 0, 7932, 7930, 1, 0, 0, 0, 7932, + 7931, 1, 0, 0, 0, 7933, 8068, 1, 0, 0, 0, 7934, 7935, 5, 312, 0, 0, 7935, + 7938, 5, 1092, 0, 0, 7936, 7939, 3, 852, 426, 0, 7937, 7939, 5, 508, 0, + 0, 7938, 7936, 1, 0, 0, 0, 7938, 7937, 1, 0, 0, 0, 7939, 8068, 1, 0, 0, + 0, 7940, 7941, 5, 316, 0, 0, 7941, 7942, 5, 1092, 0, 0, 7942, 8068, 3, + 852, 426, 0, 7943, 7944, 5, 807, 0, 0, 7944, 7945, 5, 1092, 0, 0, 7945, + 8068, 3, 880, 440, 0, 7946, 7947, 5, 803, 0, 0, 7947, 7948, 5, 1092, 0, + 0, 7948, 8068, 3, 450, 225, 0, 7949, 7950, 5, 214, 0, 0, 7950, 7953, 5, + 1092, 0, 0, 7951, 7954, 3, 852, 426, 0, 7952, 7954, 5, 62, 0, 0, 7953, + 7951, 1, 0, 0, 0, 7953, 7952, 1, 0, 0, 0, 7954, 8068, 1, 0, 0, 0, 7955, + 7956, 5, 919, 0, 0, 7956, 7959, 5, 1092, 0, 0, 7957, 7960, 3, 852, 426, + 0, 7958, 7960, 5, 62, 0, 0, 7959, 7957, 1, 0, 0, 0, 7959, 7958, 1, 0, 0, + 0, 7960, 8068, 1, 0, 0, 0, 7961, 7962, 5, 906, 0, 0, 7962, 7965, 5, 1092, + 0, 0, 7963, 7966, 3, 852, 426, 0, 7964, 7966, 5, 62, 0, 0, 7965, 7963, + 1, 0, 0, 0, 7965, 7964, 1, 0, 0, 0, 7966, 8068, 1, 0, 0, 0, 7967, 7968, + 5, 99, 0, 0, 7968, 7969, 5, 1092, 0, 0, 7969, 8068, 7, 49, 0, 0, 7970, + 7971, 5, 278, 0, 0, 7971, 7975, 5, 1092, 0, 0, 7972, 7976, 3, 424, 212, + 0, 7973, 7976, 5, 508, 0, 0, 7974, 7976, 5, 509, 0, 0, 7975, 7972, 1, 0, + 0, 0, 7975, 7973, 1, 0, 0, 0, 7975, 7974, 1, 0, 0, 0, 7976, 8068, 1, 0, + 0, 0, 7977, 7978, 5, 279, 0, 0, 7978, 7982, 5, 1092, 0, 0, 7979, 7983, + 3, 852, 426, 0, 7980, 7983, 5, 508, 0, 0, 7981, 7983, 5, 509, 0, 0, 7982, + 7979, 1, 0, 0, 0, 7982, 7980, 1, 0, 0, 0, 7982, 7981, 1, 0, 0, 0, 7983, + 8068, 1, 0, 0, 0, 7984, 7985, 5, 941, 0, 0, 7985, 7986, 5, 1092, 0, 0, + 7986, 8068, 3, 450, 225, 0, 7987, 7988, 5, 313, 0, 0, 7988, 7992, 5, 1092, + 0, 0, 7989, 7993, 3, 852, 426, 0, 7990, 7993, 5, 508, 0, 0, 7991, 7993, + 5, 509, 0, 0, 7992, 7989, 1, 0, 0, 0, 7992, 7990, 1, 0, 0, 0, 7992, 7991, + 1, 0, 0, 0, 7993, 8068, 1, 0, 0, 0, 7994, 7995, 5, 523, 0, 0, 7995, 7996, + 5, 1092, 0, 0, 7996, 7997, 5, 1104, 0, 0, 7997, 7998, 3, 854, 427, 0, 7998, + 7999, 5, 1105, 0, 0, 7999, 8068, 1, 0, 0, 0, 8000, 8001, 5, 275, 0, 0, + 8001, 8002, 5, 1092, 0, 0, 8002, 8068, 3, 450, 225, 0, 8003, 8004, 5, 685, + 0, 0, 8004, 8005, 5, 1092, 0, 0, 8005, 8068, 3, 450, 225, 0, 8006, 8007, + 5, 256, 0, 0, 8007, 8008, 5, 1092, 0, 0, 8008, 8068, 3, 450, 225, 0, 8009, + 8010, 5, 804, 0, 0, 8010, 8011, 5, 1092, 0, 0, 8011, 8068, 3, 450, 225, + 0, 8012, 8013, 5, 264, 0, 0, 8013, 8016, 5, 1092, 0, 0, 8014, 8017, 3, + 852, 426, 0, 8015, 8017, 5, 993, 0, 0, 8016, 8014, 1, 0, 0, 0, 8016, 8015, + 1, 0, 0, 0, 8017, 8068, 1, 0, 0, 0, 8018, 8019, 5, 261, 0, 0, 8019, 8020, + 5, 1092, 0, 0, 8020, 8068, 3, 450, 225, 0, 8021, 8022, 5, 33, 0, 0, 8022, + 8023, 5, 1092, 0, 0, 8023, 8068, 3, 450, 225, 0, 8024, 8025, 5, 864, 0, + 0, 8025, 8026, 5, 1092, 0, 0, 8026, 8068, 3, 450, 225, 0, 8027, 8028, 5, + 863, 0, 0, 8028, 8029, 5, 1092, 0, 0, 8029, 8068, 3, 450, 225, 0, 8030, + 8031, 5, 372, 0, 0, 8031, 8032, 5, 1092, 0, 0, 8032, 8068, 3, 450, 225, + 0, 8033, 8034, 5, 165, 0, 0, 8034, 8035, 5, 1092, 0, 0, 8035, 8068, 5, + 62, 0, 0, 8036, 8068, 5, 450, 0, 0, 8037, 8068, 5, 809, 0, 0, 8038, 8068, + 5, 508, 0, 0, 8039, 8040, 5, 810, 0, 0, 8040, 8041, 5, 1092, 0, 0, 8041, + 8068, 3, 450, 225, 0, 8042, 8043, 5, 97, 0, 0, 8043, 8044, 5, 1092, 0, + 0, 8044, 8068, 3, 450, 225, 0, 8045, 8046, 5, 165, 0, 0, 8046, 8047, 5, + 1092, 0, 0, 8047, 8068, 5, 62, 0, 0, 8048, 8068, 5, 354, 0, 0, 8049, 8068, + 5, 111, 0, 0, 8050, 8068, 5, 108, 0, 0, 8051, 8068, 5, 1038, 0, 0, 8052, + 8068, 5, 230, 0, 0, 8053, 8068, 5, 649, 0, 0, 8054, 8068, 5, 508, 0, 0, + 8055, 8056, 5, 615, 0, 0, 8056, 8057, 5, 1092, 0, 0, 8057, 8068, 3, 450, + 225, 0, 8058, 8059, 5, 865, 0, 0, 8059, 8060, 5, 1092, 0, 0, 8060, 8068, + 3, 450, 225, 0, 8061, 8062, 5, 242, 0, 0, 8062, 8063, 5, 1092, 0, 0, 8063, + 8068, 3, 450, 225, 0, 8064, 8065, 5, 241, 0, 0, 8065, 8066, 5, 1092, 0, + 0, 8066, 8068, 3, 450, 225, 0, 8067, 7925, 1, 0, 0, 0, 8067, 7928, 1, 0, + 0, 0, 8067, 7934, 1, 0, 0, 0, 8067, 7940, 1, 0, 0, 0, 8067, 7943, 1, 0, + 0, 0, 8067, 7946, 1, 0, 0, 0, 8067, 7949, 1, 0, 0, 0, 8067, 7955, 1, 0, + 0, 0, 8067, 7961, 1, 0, 0, 0, 8067, 7967, 1, 0, 0, 0, 8067, 7970, 1, 0, + 0, 0, 8067, 7977, 1, 0, 0, 0, 8067, 7984, 1, 0, 0, 0, 8067, 7987, 1, 0, + 0, 0, 8067, 7994, 1, 0, 0, 0, 8067, 8000, 1, 0, 0, 0, 8067, 8003, 1, 0, + 0, 0, 8067, 8006, 1, 0, 0, 0, 8067, 8009, 1, 0, 0, 0, 8067, 8012, 1, 0, + 0, 0, 8067, 8018, 1, 0, 0, 0, 8067, 8021, 1, 0, 0, 0, 8067, 8024, 1, 0, + 0, 0, 8067, 8027, 1, 0, 0, 0, 8067, 8030, 1, 0, 0, 0, 8067, 8033, 1, 0, + 0, 0, 8067, 8036, 1, 0, 0, 0, 8067, 8037, 1, 0, 0, 0, 8067, 8038, 1, 0, + 0, 0, 8067, 8039, 1, 0, 0, 0, 8067, 8042, 1, 0, 0, 0, 8067, 8045, 1, 0, + 0, 0, 8067, 8048, 1, 0, 0, 0, 8067, 8049, 1, 0, 0, 0, 8067, 8050, 1, 0, + 0, 0, 8067, 8051, 1, 0, 0, 0, 8067, 8052, 1, 0, 0, 0, 8067, 8053, 1, 0, + 0, 0, 8067, 8054, 1, 0, 0, 0, 8067, 8055, 1, 0, 0, 0, 8067, 8058, 1, 0, + 0, 0, 8067, 8061, 1, 0, 0, 0, 8067, 8064, 1, 0, 0, 0, 8068, 427, 1, 0, + 0, 0, 8069, 8070, 5, 557, 0, 0, 8070, 8076, 5, 1092, 0, 0, 8071, 8077, + 5, 181, 0, 0, 8072, 8077, 5, 805, 0, 0, 8073, 8077, 5, 806, 0, 0, 8074, + 8075, 5, 806, 0, 0, 8075, 8077, 5, 5, 0, 0, 8076, 8071, 1, 0, 0, 0, 8076, + 8072, 1, 0, 0, 0, 8076, 8073, 1, 0, 0, 0, 8076, 8074, 1, 0, 0, 0, 8077, + 8102, 1, 0, 0, 0, 8078, 8079, 5, 801, 0, 0, 8079, 8080, 5, 1092, 0, 0, + 8080, 8102, 3, 880, 440, 0, 8081, 8082, 5, 637, 0, 0, 8082, 8083, 5, 1092, + 0, 0, 8083, 8102, 3, 450, 225, 0, 8084, 8085, 5, 709, 0, 0, 8085, 8086, + 5, 1092, 0, 0, 8086, 8102, 3, 450, 225, 0, 8087, 8088, 5, 461, 0, 0, 8088, + 8089, 5, 1092, 0, 0, 8089, 8102, 5, 119, 0, 0, 8090, 8102, 5, 118, 0, 0, + 8091, 8102, 5, 508, 0, 0, 8092, 8093, 5, 270, 0, 0, 8093, 8094, 5, 1092, + 0, 0, 8094, 8102, 3, 450, 225, 0, 8095, 8096, 5, 946, 0, 0, 8096, 8097, + 5, 1092, 0, 0, 8097, 8102, 3, 450, 225, 0, 8098, 8099, 5, 323, 0, 0, 8099, + 8100, 5, 1092, 0, 0, 8100, 8102, 3, 450, 225, 0, 8101, 8069, 1, 0, 0, 0, + 8101, 8078, 1, 0, 0, 0, 8101, 8081, 1, 0, 0, 0, 8101, 8084, 1, 0, 0, 0, + 8101, 8087, 1, 0, 0, 0, 8101, 8090, 1, 0, 0, 0, 8101, 8091, 1, 0, 0, 0, + 8101, 8092, 1, 0, 0, 0, 8101, 8095, 1, 0, 0, 0, 8101, 8098, 1, 0, 0, 0, + 8102, 429, 1, 0, 0, 0, 8103, 8104, 5, 265, 0, 0, 8104, 8105, 5, 1092, 0, + 0, 8105, 8106, 5, 1104, 0, 0, 8106, 8107, 5, 954, 0, 0, 8107, 8112, 5, + 1092, 0, 0, 8108, 8109, 5, 954, 0, 0, 8109, 8110, 5, 1092, 0, 0, 8110, + 8112, 5, 1105, 0, 0, 8111, 8103, 1, 0, 0, 0, 8111, 8108, 1, 0, 0, 0, 8112, + 431, 1, 0, 0, 0, 8113, 8114, 5, 954, 0, 0, 8114, 8115, 5, 1092, 0, 0, 8115, + 8116, 3, 852, 426, 0, 8116, 433, 1, 0, 0, 0, 8117, 8118, 5, 457, 0, 0, + 8118, 8119, 5, 1092, 0, 0, 8119, 8120, 3, 852, 426, 0, 8120, 435, 1, 0, + 0, 0, 8121, 8122, 5, 416, 0, 0, 8122, 8123, 5, 1092, 0, 0, 8123, 8124, + 3, 852, 426, 0, 8124, 437, 1, 0, 0, 0, 8125, 8126, 5, 265, 0, 0, 8126, + 8127, 5, 1092, 0, 0, 8127, 8144, 5, 1104, 0, 0, 8128, 8130, 3, 432, 216, + 0, 8129, 8128, 1, 0, 0, 0, 8129, 8130, 1, 0, 0, 0, 8130, 8131, 1, 0, 0, + 0, 8131, 8145, 3, 434, 217, 0, 8132, 8134, 3, 432, 216, 0, 8133, 8132, + 1, 0, 0, 0, 8133, 8134, 1, 0, 0, 0, 8134, 8145, 1, 0, 0, 0, 8135, 8137, + 3, 432, 216, 0, 8136, 8138, 3, 436, 218, 0, 8137, 8136, 1, 0, 0, 0, 8137, + 8138, 1, 0, 0, 0, 8138, 8140, 1, 0, 0, 0, 8139, 8135, 1, 0, 0, 0, 8139, + 8140, 1, 0, 0, 0, 8140, 8145, 1, 0, 0, 0, 8141, 8143, 3, 432, 216, 0, 8142, + 8141, 1, 0, 0, 0, 8142, 8143, 1, 0, 0, 0, 8143, 8145, 1, 0, 0, 0, 8144, + 8129, 1, 0, 0, 0, 8144, 8133, 1, 0, 0, 0, 8144, 8139, 1, 0, 0, 0, 8144, + 8142, 1, 0, 0, 0, 8145, 8146, 1, 0, 0, 0, 8146, 8147, 5, 1105, 0, 0, 8147, + 439, 1, 0, 0, 0, 8148, 8149, 5, 83, 0, 0, 8149, 8150, 5, 1092, 0, 0, 8150, + 8151, 3, 852, 426, 0, 8151, 441, 1, 0, 0, 0, 8152, 8153, 5, 76, 0, 0, 8153, + 8154, 5, 1092, 0, 0, 8154, 8155, 3, 852, 426, 0, 8155, 443, 1, 0, 0, 0, + 8156, 8157, 5, 78, 0, 0, 8157, 8158, 5, 1092, 0, 0, 8158, 8159, 3, 852, + 426, 0, 8159, 445, 1, 0, 0, 0, 8160, 8161, 5, 77, 0, 0, 8161, 8162, 5, + 1092, 0, 0, 8162, 8163, 3, 852, 426, 0, 8163, 447, 1, 0, 0, 0, 8164, 8165, + 5, 980, 0, 0, 8165, 8166, 5, 1092, 0, 0, 8166, 8183, 3, 854, 427, 0, 8167, + 8168, 5, 854, 0, 0, 8168, 8169, 5, 1092, 0, 0, 8169, 8184, 3, 856, 428, + 0, 8170, 8171, 5, 191, 0, 0, 8171, 8172, 5, 1092, 0, 0, 8172, 8179, 5, + 1104, 0, 0, 8173, 8174, 3, 442, 221, 0, 8174, 8176, 3, 444, 222, 0, 8175, + 8177, 3, 440, 220, 0, 8176, 8175, 1, 0, 0, 0, 8176, 8177, 1, 0, 0, 0, 8177, + 8180, 1, 0, 0, 0, 8178, 8180, 3, 446, 223, 0, 8179, 8173, 1, 0, 0, 0, 8179, + 8178, 1, 0, 0, 0, 8180, 8181, 1, 0, 0, 0, 8181, 8182, 5, 1105, 0, 0, 8182, + 8184, 1, 0, 0, 0, 8183, 8167, 1, 0, 0, 0, 8183, 8170, 1, 0, 0, 0, 8183, + 8184, 1, 0, 0, 0, 8184, 8186, 1, 0, 0, 0, 8185, 8187, 3, 438, 219, 0, 8186, + 8185, 1, 0, 0, 0, 8186, 8187, 1, 0, 0, 0, 8187, 8254, 1, 0, 0, 0, 8188, + 8189, 5, 980, 0, 0, 8189, 8190, 5, 1092, 0, 0, 8190, 8194, 3, 852, 426, + 0, 8191, 8192, 5, 854, 0, 0, 8192, 8193, 5, 1092, 0, 0, 8193, 8195, 3, + 856, 428, 0, 8194, 8191, 1, 0, 0, 0, 8194, 8195, 1, 0, 0, 0, 8195, 8214, + 1, 0, 0, 0, 8196, 8197, 5, 265, 0, 0, 8197, 8212, 5, 1092, 0, 0, 8198, + 8199, 5, 954, 0, 0, 8199, 8201, 5, 1092, 0, 0, 8200, 8198, 1, 0, 0, 0, + 8200, 8201, 1, 0, 0, 0, 8201, 8205, 1, 0, 0, 0, 8202, 8203, 5, 416, 0, + 0, 8203, 8204, 5, 1092, 0, 0, 8204, 8206, 3, 852, 426, 0, 8205, 8202, 1, + 0, 0, 0, 8205, 8206, 1, 0, 0, 0, 8206, 8213, 1, 0, 0, 0, 8207, 8208, 5, + 954, 0, 0, 8208, 8209, 5, 1092, 0, 0, 8209, 8211, 5, 508, 0, 0, 8210, 8207, + 1, 0, 0, 0, 8210, 8211, 1, 0, 0, 0, 8211, 8213, 1, 0, 0, 0, 8212, 8200, + 1, 0, 0, 0, 8212, 8210, 1, 0, 0, 0, 8213, 8215, 1, 0, 0, 0, 8214, 8196, + 1, 0, 0, 0, 8214, 8215, 1, 0, 0, 0, 8215, 8254, 1, 0, 0, 0, 8216, 8217, + 5, 980, 0, 0, 8217, 8218, 5, 1092, 0, 0, 8218, 8231, 3, 852, 426, 0, 8219, + 8220, 5, 854, 0, 0, 8220, 8221, 5, 1092, 0, 0, 8221, 8232, 3, 856, 428, + 0, 8222, 8223, 5, 191, 0, 0, 8223, 8224, 5, 1092, 0, 0, 8224, 8228, 5, + 1104, 0, 0, 8225, 8226, 5, 89, 0, 0, 8226, 8227, 5, 1092, 0, 0, 8227, 8229, + 3, 852, 426, 0, 8228, 8225, 1, 0, 0, 0, 8228, 8229, 1, 0, 0, 0, 8229, 8230, + 1, 0, 0, 0, 8230, 8232, 5, 1105, 0, 0, 8231, 8219, 1, 0, 0, 0, 8231, 8222, + 1, 0, 0, 0, 8231, 8232, 1, 0, 0, 0, 8232, 8251, 1, 0, 0, 0, 8233, 8234, + 5, 265, 0, 0, 8234, 8235, 5, 1092, 0, 0, 8235, 8238, 5, 1104, 0, 0, 8236, + 8237, 5, 954, 0, 0, 8237, 8239, 5, 1092, 0, 0, 8238, 8236, 1, 0, 0, 0, + 8238, 8239, 1, 0, 0, 0, 8239, 8243, 1, 0, 0, 0, 8240, 8241, 5, 457, 0, + 0, 8241, 8242, 5, 1092, 0, 0, 8242, 8244, 3, 852, 426, 0, 8243, 8240, 1, + 0, 0, 0, 8243, 8244, 1, 0, 0, 0, 8244, 8252, 1, 0, 0, 0, 8245, 8246, 5, + 954, 0, 0, 8246, 8247, 5, 1092, 0, 0, 8247, 8249, 5, 508, 0, 0, 8248, 8245, + 1, 0, 0, 0, 8248, 8249, 1, 0, 0, 0, 8249, 8250, 1, 0, 0, 0, 8250, 8252, + 5, 1105, 0, 0, 8251, 8233, 1, 0, 0, 0, 8251, 8248, 1, 0, 0, 0, 8251, 8252, + 1, 0, 0, 0, 8252, 8254, 1, 0, 0, 0, 8253, 8164, 1, 0, 0, 0, 8253, 8188, + 1, 0, 0, 0, 8253, 8216, 1, 0, 0, 0, 8254, 449, 1, 0, 0, 0, 8255, 8256, + 7, 50, 0, 0, 8256, 451, 1, 0, 0, 0, 8257, 8258, 5, 257, 0, 0, 8258, 8259, + 5, 1092, 0, 0, 8259, 8260, 3, 450, 225, 0, 8260, 453, 1, 0, 0, 0, 8261, + 8262, 5, 672, 0, 0, 8262, 8263, 5, 1092, 0, 0, 8263, 8264, 3, 450, 225, + 0, 8264, 455, 1, 0, 0, 0, 8265, 8266, 5, 70, 0, 0, 8266, 8267, 5, 1092, + 0, 0, 8267, 8268, 3, 450, 225, 0, 8268, 457, 1, 0, 0, 0, 8269, 8270, 5, + 514, 0, 0, 8270, 8271, 5, 1092, 0, 0, 8271, 8272, 3, 852, 426, 0, 8272, + 459, 1, 0, 0, 0, 8273, 8274, 5, 238, 0, 0, 8274, 8275, 5, 1092, 0, 0, 8275, + 8276, 5, 1104, 0, 0, 8276, 8278, 3, 452, 226, 0, 8277, 8279, 3, 454, 227, + 0, 8278, 8277, 1, 0, 0, 0, 8278, 8279, 1, 0, 0, 0, 8279, 8280, 1, 0, 0, + 0, 8280, 8281, 5, 1105, 0, 0, 8281, 8325, 1, 0, 0, 0, 8282, 8283, 5, 238, + 0, 0, 8283, 8284, 5, 1092, 0, 0, 8284, 8285, 5, 1104, 0, 0, 8285, 8287, + 3, 452, 226, 0, 8286, 8288, 3, 454, 227, 0, 8287, 8286, 1, 0, 0, 0, 8287, + 8288, 1, 0, 0, 0, 8288, 8290, 1, 0, 0, 0, 8289, 8291, 3, 456, 228, 0, 8290, + 8289, 1, 0, 0, 0, 8290, 8291, 1, 0, 0, 0, 8291, 8292, 1, 0, 0, 0, 8292, + 8293, 5, 1105, 0, 0, 8293, 8325, 1, 0, 0, 0, 8294, 8295, 5, 238, 0, 0, + 8295, 8296, 5, 1092, 0, 0, 8296, 8297, 5, 1104, 0, 0, 8297, 8299, 3, 452, + 226, 0, 8298, 8300, 3, 456, 228, 0, 8299, 8298, 1, 0, 0, 0, 8299, 8300, + 1, 0, 0, 0, 8300, 8302, 1, 0, 0, 0, 8301, 8303, 3, 454, 227, 0, 8302, 8301, + 1, 0, 0, 0, 8302, 8303, 1, 0, 0, 0, 8303, 8305, 1, 0, 0, 0, 8304, 8306, + 3, 458, 229, 0, 8305, 8304, 1, 0, 0, 0, 8305, 8306, 1, 0, 0, 0, 8306, 8307, + 1, 0, 0, 0, 8307, 8308, 5, 1105, 0, 0, 8308, 8325, 1, 0, 0, 0, 8309, 8310, + 5, 238, 0, 0, 8310, 8311, 5, 1092, 0, 0, 8311, 8312, 5, 1104, 0, 0, 8312, + 8314, 3, 452, 226, 0, 8313, 8315, 3, 454, 227, 0, 8314, 8313, 1, 0, 0, + 0, 8314, 8315, 1, 0, 0, 0, 8315, 8317, 1, 0, 0, 0, 8316, 8318, 3, 456, + 228, 0, 8317, 8316, 1, 0, 0, 0, 8317, 8318, 1, 0, 0, 0, 8318, 8320, 1, + 0, 0, 0, 8319, 8321, 3, 458, 229, 0, 8320, 8319, 1, 0, 0, 0, 8320, 8321, + 1, 0, 0, 0, 8321, 8322, 1, 0, 0, 0, 8322, 8323, 5, 1105, 0, 0, 8323, 8325, + 1, 0, 0, 0, 8324, 8273, 1, 0, 0, 0, 8324, 8282, 1, 0, 0, 0, 8324, 8294, + 1, 0, 0, 0, 8324, 8309, 1, 0, 0, 0, 8325, 461, 1, 0, 0, 0, 8326, 8328, + 5, 190, 0, 0, 8327, 8329, 3, 654, 327, 0, 8328, 8327, 1, 0, 0, 0, 8328, + 8329, 1, 0, 0, 0, 8329, 8331, 1, 0, 0, 0, 8330, 8332, 5, 894, 0, 0, 8331, + 8330, 1, 0, 0, 0, 8331, 8332, 1, 0, 0, 0, 8332, 8333, 1, 0, 0, 0, 8333, + 8335, 5, 822, 0, 0, 8334, 8336, 3, 652, 326, 0, 8335, 8334, 1, 0, 0, 0, + 8335, 8336, 1, 0, 0, 0, 8336, 8337, 1, 0, 0, 0, 8337, 8339, 3, 878, 439, + 0, 8338, 8340, 3, 430, 215, 0, 8339, 8338, 1, 0, 0, 0, 8339, 8340, 1, 0, + 0, 0, 8340, 8342, 1, 0, 0, 0, 8341, 8343, 3, 460, 230, 0, 8342, 8341, 1, + 0, 0, 0, 8342, 8343, 1, 0, 0, 0, 8343, 8362, 1, 0, 0, 0, 8344, 8345, 5, + 317, 0, 0, 8345, 8346, 5, 1092, 0, 0, 8346, 8359, 5, 1104, 0, 0, 8347, + 8348, 5, 327, 0, 0, 8348, 8349, 5, 1092, 0, 0, 8349, 8360, 3, 852, 426, + 0, 8350, 8351, 5, 954, 0, 0, 8351, 8352, 5, 1092, 0, 0, 8352, 8356, 7, + 3, 0, 0, 8353, 8355, 3, 426, 213, 0, 8354, 8353, 1, 0, 0, 0, 8355, 8358, + 1, 0, 0, 0, 8356, 8354, 1, 0, 0, 0, 8356, 8357, 1, 0, 0, 0, 8357, 8360, + 1, 0, 0, 0, 8358, 8356, 1, 0, 0, 0, 8359, 8347, 1, 0, 0, 0, 8359, 8350, + 1, 0, 0, 0, 8360, 8361, 1, 0, 0, 0, 8361, 8363, 5, 1105, 0, 0, 8362, 8344, + 1, 0, 0, 0, 8362, 8363, 1, 0, 0, 0, 8363, 8370, 1, 0, 0, 0, 8364, 8365, + 5, 187, 0, 0, 8365, 8366, 5, 1092, 0, 0, 8366, 8367, 5, 1104, 0, 0, 8367, + 8368, 3, 428, 214, 0, 8368, 8369, 5, 1105, 0, 0, 8369, 8371, 1, 0, 0, 0, + 8370, 8364, 1, 0, 0, 0, 8370, 8371, 1, 0, 0, 0, 8371, 8373, 1, 0, 0, 0, + 8372, 8374, 3, 488, 244, 0, 8373, 8372, 1, 0, 0, 0, 8373, 8374, 1, 0, 0, + 0, 8374, 8376, 1, 0, 0, 0, 8375, 8377, 3, 646, 323, 0, 8376, 8375, 1, 0, + 0, 0, 8376, 8377, 1, 0, 0, 0, 8377, 8429, 1, 0, 0, 0, 8378, 8380, 5, 190, + 0, 0, 8379, 8381, 3, 654, 327, 0, 8380, 8379, 1, 0, 0, 0, 8380, 8381, 1, + 0, 0, 0, 8381, 8383, 1, 0, 0, 0, 8382, 8384, 5, 894, 0, 0, 8383, 8382, + 1, 0, 0, 0, 8383, 8384, 1, 0, 0, 0, 8384, 8385, 1, 0, 0, 0, 8385, 8387, + 5, 822, 0, 0, 8386, 8388, 3, 652, 326, 0, 8387, 8386, 1, 0, 0, 0, 8387, + 8388, 1, 0, 0, 0, 8388, 8389, 1, 0, 0, 0, 8389, 8390, 3, 878, 439, 0, 8390, + 8392, 3, 448, 224, 0, 8391, 8393, 3, 460, 230, 0, 8392, 8391, 1, 0, 0, + 0, 8392, 8393, 1, 0, 0, 0, 8393, 8412, 1, 0, 0, 0, 8394, 8395, 5, 317, + 0, 0, 8395, 8396, 5, 1092, 0, 0, 8396, 8409, 5, 1104, 0, 0, 8397, 8398, + 5, 327, 0, 0, 8398, 8399, 5, 1092, 0, 0, 8399, 8410, 3, 852, 426, 0, 8400, + 8401, 5, 954, 0, 0, 8401, 8402, 5, 1092, 0, 0, 8402, 8406, 7, 3, 0, 0, + 8403, 8405, 3, 426, 213, 0, 8404, 8403, 1, 0, 0, 0, 8405, 8408, 1, 0, 0, + 0, 8406, 8404, 1, 0, 0, 0, 8406, 8407, 1, 0, 0, 0, 8407, 8410, 1, 0, 0, + 0, 8408, 8406, 1, 0, 0, 0, 8409, 8397, 1, 0, 0, 0, 8409, 8400, 1, 0, 0, + 0, 8410, 8411, 1, 0, 0, 0, 8411, 8413, 5, 1105, 0, 0, 8412, 8394, 1, 0, + 0, 0, 8412, 8413, 1, 0, 0, 0, 8413, 8420, 1, 0, 0, 0, 8414, 8415, 5, 187, + 0, 0, 8415, 8416, 5, 1092, 0, 0, 8416, 8417, 5, 1104, 0, 0, 8417, 8418, + 3, 428, 214, 0, 8418, 8419, 5, 1105, 0, 0, 8419, 8421, 1, 0, 0, 0, 8420, + 8414, 1, 0, 0, 0, 8420, 8421, 1, 0, 0, 0, 8421, 8423, 1, 0, 0, 0, 8422, + 8424, 3, 488, 244, 0, 8423, 8422, 1, 0, 0, 0, 8423, 8424, 1, 0, 0, 0, 8424, + 8426, 1, 0, 0, 0, 8425, 8427, 3, 646, 323, 0, 8426, 8425, 1, 0, 0, 0, 8426, + 8427, 1, 0, 0, 0, 8427, 8429, 1, 0, 0, 0, 8428, 8326, 1, 0, 0, 0, 8428, + 8378, 1, 0, 0, 0, 8429, 463, 1, 0, 0, 0, 8430, 8431, 5, 855, 0, 0, 8431, + 8432, 5, 1092, 0, 0, 8432, 8433, 5, 734, 0, 0, 8433, 8434, 5, 852, 0, 0, + 8434, 8435, 5, 1092, 0, 0, 8435, 8439, 3, 852, 426, 0, 8436, 8437, 5, 851, + 0, 0, 8437, 8438, 5, 1092, 0, 0, 8438, 8440, 3, 852, 426, 0, 8439, 8436, + 1, 0, 0, 0, 8439, 8440, 1, 0, 0, 0, 8440, 8451, 1, 0, 0, 0, 8441, 8442, + 5, 855, 0, 0, 8442, 8443, 5, 1092, 0, 0, 8443, 8451, 5, 337, 0, 0, 8444, + 8445, 5, 855, 0, 0, 8445, 8446, 5, 1092, 0, 0, 8446, 8447, 5, 84, 0, 0, + 8447, 8448, 5, 91, 0, 0, 8448, 8449, 5, 1092, 0, 0, 8449, 8451, 3, 852, + 426, 0, 8450, 8430, 1, 0, 0, 0, 8450, 8441, 1, 0, 0, 0, 8450, 8444, 1, + 0, 0, 0, 8451, 465, 1, 0, 0, 0, 8452, 8453, 5, 852, 0, 0, 8453, 8454, 5, + 1092, 0, 0, 8454, 8458, 3, 852, 426, 0, 8455, 8456, 5, 851, 0, 0, 8456, + 8457, 5, 1092, 0, 0, 8457, 8459, 3, 852, 426, 0, 8458, 8455, 1, 0, 0, 0, + 8458, 8459, 1, 0, 0, 0, 8459, 8464, 1, 0, 0, 0, 8460, 8461, 5, 91, 0, 0, + 8461, 8462, 5, 1092, 0, 0, 8462, 8464, 3, 852, 426, 0, 8463, 8452, 1, 0, + 0, 0, 8463, 8460, 1, 0, 0, 0, 8464, 467, 1, 0, 0, 0, 8465, 8466, 5, 394, + 0, 0, 8466, 8467, 5, 1092, 0, 0, 8467, 8468, 3, 852, 426, 0, 8468, 469, + 1, 0, 0, 0, 8469, 8471, 5, 190, 0, 0, 8470, 8472, 3, 654, 327, 0, 8471, + 8470, 1, 0, 0, 0, 8471, 8472, 1, 0, 0, 0, 8472, 8473, 1, 0, 0, 0, 8473, + 8474, 5, 849, 0, 0, 8474, 8476, 5, 394, 0, 0, 8475, 8477, 3, 652, 326, + 0, 8476, 8475, 1, 0, 0, 0, 8476, 8477, 1, 0, 0, 0, 8477, 8478, 1, 0, 0, + 0, 8478, 8479, 3, 856, 428, 0, 8479, 8480, 5, 954, 0, 0, 8480, 8481, 5, + 1092, 0, 0, 8481, 8482, 5, 306, 0, 0, 8482, 8483, 3, 464, 232, 0, 8483, + 8484, 5, 258, 0, 0, 8484, 8485, 5, 1092, 0, 0, 8485, 8486, 3, 450, 225, + 0, 8486, 8487, 5, 850, 0, 0, 8487, 8488, 5, 1092, 0, 0, 8488, 8489, 5, + 1104, 0, 0, 8489, 8490, 3, 854, 427, 0, 8490, 8497, 5, 1105, 0, 0, 8491, + 8492, 5, 853, 0, 0, 8492, 8493, 5, 1092, 0, 0, 8493, 8494, 5, 1104, 0, + 0, 8494, 8495, 3, 854, 427, 0, 8495, 8496, 5, 1105, 0, 0, 8496, 8498, 1, + 0, 0, 0, 8497, 8491, 1, 0, 0, 0, 8497, 8498, 1, 0, 0, 0, 8498, 8500, 1, + 0, 0, 0, 8499, 8501, 3, 646, 323, 0, 8500, 8499, 1, 0, 0, 0, 8500, 8501, + 1, 0, 0, 0, 8501, 471, 1, 0, 0, 0, 8502, 8503, 5, 185, 0, 0, 8503, 8504, + 5, 349, 0, 0, 8504, 473, 1, 0, 0, 0, 8505, 8506, 5, 52, 0, 0, 8506, 8507, + 5, 1092, 0, 0, 8507, 8508, 3, 450, 225, 0, 8508, 475, 1, 0, 0, 0, 8509, + 8510, 5, 391, 0, 0, 8510, 8511, 5, 1092, 0, 0, 8511, 8512, 5, 944, 0, 0, + 8512, 477, 1, 0, 0, 0, 8513, 8514, 5, 795, 0, 0, 8514, 8515, 5, 1092, 0, + 0, 8515, 8516, 3, 450, 225, 0, 8516, 479, 1, 0, 0, 0, 8517, 8518, 3, 328, + 164, 0, 8518, 8531, 5, 1104, 0, 0, 8519, 8520, 5, 904, 0, 0, 8520, 8521, + 5, 1089, 0, 0, 8521, 8532, 3, 852, 426, 0, 8522, 8523, 5, 544, 0, 0, 8523, + 8524, 5, 1089, 0, 0, 8524, 8532, 3, 852, 426, 0, 8525, 8526, 5, 834, 0, + 0, 8526, 8527, 5, 1089, 0, 0, 8527, 8532, 3, 856, 428, 0, 8528, 8529, 5, + 857, 0, 0, 8529, 8530, 5, 1089, 0, 0, 8530, 8532, 3, 852, 426, 0, 8531, + 8519, 1, 0, 0, 0, 8531, 8522, 1, 0, 0, 0, 8531, 8525, 1, 0, 0, 0, 8531, + 8528, 1, 0, 0, 0, 8532, 8533, 1, 0, 0, 0, 8533, 8534, 5, 1105, 0, 0, 8534, + 481, 1, 0, 0, 0, 8535, 8537, 5, 190, 0, 0, 8536, 8538, 3, 654, 327, 0, + 8537, 8536, 1, 0, 0, 0, 8537, 8538, 1, 0, 0, 0, 8538, 8539, 1, 0, 0, 0, + 8539, 8541, 5, 857, 0, 0, 8540, 8542, 3, 652, 326, 0, 8541, 8540, 1, 0, + 0, 0, 8541, 8542, 1, 0, 0, 0, 8542, 8543, 1, 0, 0, 0, 8543, 8545, 3, 878, + 439, 0, 8544, 8546, 3, 472, 236, 0, 8545, 8544, 1, 0, 0, 0, 8545, 8546, + 1, 0, 0, 0, 8546, 8547, 1, 0, 0, 0, 8547, 8548, 5, 553, 0, 0, 8548, 8549, + 5, 880, 0, 0, 8549, 8551, 3, 878, 439, 0, 8550, 8552, 3, 480, 240, 0, 8551, + 8550, 1, 0, 0, 0, 8551, 8552, 1, 0, 0, 0, 8552, 8554, 1, 0, 0, 0, 8553, + 8555, 3, 474, 237, 0, 8554, 8553, 1, 0, 0, 0, 8554, 8555, 1, 0, 0, 0, 8555, + 8557, 1, 0, 0, 0, 8556, 8558, 3, 478, 239, 0, 8557, 8556, 1, 0, 0, 0, 8557, + 8558, 1, 0, 0, 0, 8558, 8560, 1, 0, 0, 0, 8559, 8561, 3, 646, 323, 0, 8560, + 8559, 1, 0, 0, 0, 8560, 8561, 1, 0, 0, 0, 8561, 8633, 1, 0, 0, 0, 8562, + 8564, 5, 190, 0, 0, 8563, 8565, 3, 654, 327, 0, 8564, 8563, 1, 0, 0, 0, + 8564, 8565, 1, 0, 0, 0, 8565, 8566, 1, 0, 0, 0, 8566, 8568, 5, 857, 0, + 0, 8567, 8569, 3, 652, 326, 0, 8568, 8567, 1, 0, 0, 0, 8568, 8569, 1, 0, + 0, 0, 8569, 8570, 1, 0, 0, 0, 8570, 8572, 3, 878, 439, 0, 8571, 8573, 3, + 472, 236, 0, 8572, 8571, 1, 0, 0, 0, 8572, 8573, 1, 0, 0, 0, 8573, 8574, + 1, 0, 0, 0, 8574, 8575, 5, 553, 0, 0, 8575, 8576, 5, 291, 0, 0, 8576, 8577, + 5, 880, 0, 0, 8577, 8579, 3, 878, 439, 0, 8578, 8580, 3, 480, 240, 0, 8579, + 8578, 1, 0, 0, 0, 8579, 8580, 1, 0, 0, 0, 8580, 8582, 1, 0, 0, 0, 8581, + 8583, 3, 476, 238, 0, 8582, 8581, 1, 0, 0, 0, 8582, 8583, 1, 0, 0, 0, 8583, + 8585, 1, 0, 0, 0, 8584, 8586, 3, 646, 323, 0, 8585, 8584, 1, 0, 0, 0, 8585, + 8586, 1, 0, 0, 0, 8586, 8633, 1, 0, 0, 0, 8587, 8589, 5, 190, 0, 0, 8588, + 8590, 3, 654, 327, 0, 8589, 8588, 1, 0, 0, 0, 8589, 8590, 1, 0, 0, 0, 8590, + 8591, 1, 0, 0, 0, 8591, 8593, 5, 857, 0, 0, 8592, 8594, 3, 652, 326, 0, + 8593, 8592, 1, 0, 0, 0, 8593, 8594, 1, 0, 0, 0, 8594, 8595, 1, 0, 0, 0, + 8595, 8597, 3, 878, 439, 0, 8596, 8598, 3, 472, 236, 0, 8597, 8596, 1, + 0, 0, 0, 8597, 8598, 1, 0, 0, 0, 8598, 8599, 1, 0, 0, 0, 8599, 8600, 5, + 553, 0, 0, 8600, 8601, 5, 822, 0, 0, 8601, 8603, 3, 878, 439, 0, 8602, + 8604, 3, 646, 323, 0, 8603, 8602, 1, 0, 0, 0, 8603, 8604, 1, 0, 0, 0, 8604, + 8633, 1, 0, 0, 0, 8605, 8607, 5, 190, 0, 0, 8606, 8608, 3, 654, 327, 0, + 8607, 8606, 1, 0, 0, 0, 8607, 8608, 1, 0, 0, 0, 8608, 8609, 1, 0, 0, 0, + 8609, 8611, 5, 857, 0, 0, 8610, 8612, 3, 652, 326, 0, 8611, 8610, 1, 0, + 0, 0, 8611, 8612, 1, 0, 0, 0, 8612, 8613, 1, 0, 0, 0, 8613, 8615, 3, 878, + 439, 0, 8614, 8616, 3, 472, 236, 0, 8615, 8614, 1, 0, 0, 0, 8615, 8616, + 1, 0, 0, 0, 8616, 8617, 1, 0, 0, 0, 8617, 8618, 5, 553, 0, 0, 8618, 8619, + 5, 1005, 0, 0, 8619, 8621, 3, 878, 439, 0, 8620, 8622, 3, 480, 240, 0, + 8621, 8620, 1, 0, 0, 0, 8621, 8622, 1, 0, 0, 0, 8622, 8624, 1, 0, 0, 0, + 8623, 8625, 3, 474, 237, 0, 8624, 8623, 1, 0, 0, 0, 8624, 8625, 1, 0, 0, + 0, 8625, 8627, 1, 0, 0, 0, 8626, 8628, 3, 478, 239, 0, 8627, 8626, 1, 0, + 0, 0, 8627, 8628, 1, 0, 0, 0, 8628, 8630, 1, 0, 0, 0, 8629, 8631, 3, 646, + 323, 0, 8630, 8629, 1, 0, 0, 0, 8630, 8631, 1, 0, 0, 0, 8631, 8633, 1, + 0, 0, 0, 8632, 8535, 1, 0, 0, 0, 8632, 8562, 1, 0, 0, 0, 8632, 8587, 1, + 0, 0, 0, 8632, 8605, 1, 0, 0, 0, 8633, 483, 1, 0, 0, 0, 8634, 8635, 7, + 51, 0, 0, 8635, 485, 1, 0, 0, 0, 8636, 8638, 7, 52, 0, 0, 8637, 8636, 1, + 0, 0, 0, 8637, 8638, 1, 0, 0, 0, 8638, 8639, 1, 0, 0, 0, 8639, 8642, 3, + 484, 242, 0, 8640, 8642, 5, 1009, 0, 0, 8641, 8637, 1, 0, 0, 0, 8641, 8640, + 1, 0, 0, 0, 8642, 8645, 1, 0, 0, 0, 8643, 8645, 5, 936, 0, 0, 8644, 8641, + 1, 0, 0, 0, 8644, 8643, 1, 0, 0, 0, 8645, 487, 1, 0, 0, 0, 8646, 8648, + 5, 1020, 0, 0, 8647, 8646, 1, 0, 0, 0, 8647, 8648, 1, 0, 0, 0, 8648, 8649, + 1, 0, 0, 0, 8649, 8650, 5, 887, 0, 0, 8650, 8651, 5, 1104, 0, 0, 8651, + 8656, 3, 366, 183, 0, 8652, 8653, 5, 1110, 0, 0, 8653, 8655, 3, 366, 183, + 0, 8654, 8652, 1, 0, 0, 0, 8655, 8658, 1, 0, 0, 0, 8656, 8654, 1, 0, 0, + 0, 8656, 8657, 1, 0, 0, 0, 8657, 8659, 1, 0, 0, 0, 8658, 8656, 1, 0, 0, + 0, 8659, 8660, 5, 1105, 0, 0, 8660, 489, 1, 0, 0, 0, 8661, 8663, 5, 1020, + 0, 0, 8662, 8661, 1, 0, 0, 0, 8662, 8663, 1, 0, 0, 0, 8663, 8664, 1, 0, + 0, 0, 8664, 8665, 5, 723, 0, 0, 8665, 8666, 5, 8, 0, 0, 8666, 8667, 5, + 608, 0, 0, 8667, 8668, 3, 856, 428, 0, 8668, 8669, 5, 553, 0, 0, 8669, + 8670, 5, 1104, 0, 0, 8670, 8675, 3, 874, 437, 0, 8671, 8672, 5, 1110, 0, + 0, 8672, 8674, 3, 874, 437, 0, 8673, 8671, 1, 0, 0, 0, 8674, 8677, 1, 0, + 0, 0, 8675, 8673, 1, 0, 0, 0, 8675, 8676, 1, 0, 0, 0, 8676, 8678, 1, 0, + 0, 0, 8677, 8675, 1, 0, 0, 0, 8678, 8679, 5, 1105, 0, 0, 8679, 491, 1, + 0, 0, 0, 8680, 8681, 5, 151, 0, 0, 8681, 8682, 5, 110, 0, 0, 8682, 8683, + 3, 1038, 519, 0, 8683, 493, 1, 0, 0, 0, 8684, 8685, 5, 127, 0, 0, 8685, + 8686, 5, 1092, 0, 0, 8686, 8687, 3, 450, 225, 0, 8687, 495, 1, 0, 0, 0, + 8688, 8690, 5, 1020, 0, 0, 8689, 8688, 1, 0, 0, 0, 8689, 8690, 1, 0, 0, + 0, 8690, 8691, 1, 0, 0, 0, 8691, 8692, 5, 455, 0, 0, 8692, 8693, 5, 608, + 0, 0, 8693, 8696, 3, 856, 428, 0, 8694, 8695, 5, 992, 0, 0, 8695, 8697, + 3, 368, 184, 0, 8696, 8694, 1, 0, 0, 0, 8696, 8697, 1, 0, 0, 0, 8697, 497, + 1, 0, 0, 0, 8698, 8699, 5, 155, 0, 0, 8699, 8700, 3, 852, 426, 0, 8700, + 499, 1, 0, 0, 0, 8701, 8702, 5, 511, 0, 0, 8702, 8703, 5, 522, 0, 0, 8703, + 501, 1, 0, 0, 0, 8704, 8705, 5, 221, 0, 0, 8705, 8721, 3, 886, 443, 0, + 8706, 8718, 7, 30, 0, 0, 8707, 8708, 5, 1104, 0, 0, 8708, 8709, 3, 880, + 440, 0, 8709, 8710, 5, 1110, 0, 0, 8710, 8711, 3, 880, 440, 0, 8711, 8712, + 5, 1105, 0, 0, 8712, 8719, 1, 0, 0, 0, 8713, 8719, 3, 414, 207, 0, 8714, + 8719, 3, 416, 208, 0, 8715, 8716, 3, 414, 207, 0, 8716, 8717, 3, 416, 208, + 0, 8717, 8719, 1, 0, 0, 0, 8718, 8707, 1, 0, 0, 0, 8718, 8713, 1, 0, 0, + 0, 8718, 8714, 1, 0, 0, 0, 8718, 8715, 1, 0, 0, 0, 8718, 8719, 1, 0, 0, + 0, 8719, 8721, 1, 0, 0, 0, 8720, 8704, 1, 0, 0, 0, 8720, 8706, 1, 0, 0, + 0, 8721, 503, 1, 0, 0, 0, 8722, 8723, 5, 324, 0, 0, 8723, 8724, 5, 413, + 0, 0, 8724, 505, 1, 0, 0, 0, 8725, 8726, 5, 174, 0, 0, 8726, 8728, 3, 856, + 428, 0, 8727, 8725, 1, 0, 0, 0, 8727, 8728, 1, 0, 0, 0, 8728, 8749, 1, + 0, 0, 0, 8729, 8731, 5, 966, 0, 0, 8730, 8732, 3, 368, 184, 0, 8731, 8730, + 1, 0, 0, 0, 8731, 8732, 1, 0, 0, 0, 8732, 8750, 1, 0, 0, 0, 8733, 8734, + 5, 619, 0, 0, 8734, 8736, 5, 413, 0, 0, 8735, 8737, 3, 368, 184, 0, 8736, + 8735, 1, 0, 0, 0, 8736, 8737, 1, 0, 0, 0, 8737, 8750, 1, 0, 0, 0, 8738, + 8740, 3, 504, 252, 0, 8739, 8738, 1, 0, 0, 0, 8739, 8740, 1, 0, 0, 0, 8740, + 8742, 1, 0, 0, 0, 8741, 8743, 3, 368, 184, 0, 8742, 8741, 1, 0, 0, 0, 8742, + 8743, 1, 0, 0, 0, 8743, 8744, 1, 0, 0, 0, 8744, 8745, 5, 669, 0, 0, 8745, + 8747, 3, 878, 439, 0, 8746, 8748, 3, 368, 184, 0, 8747, 8746, 1, 0, 0, + 0, 8747, 8748, 1, 0, 0, 0, 8748, 8750, 1, 0, 0, 0, 8749, 8729, 1, 0, 0, + 0, 8749, 8733, 1, 0, 0, 0, 8749, 8739, 1, 0, 0, 0, 8750, 8752, 1, 0, 0, + 0, 8751, 8753, 3, 254, 127, 0, 8752, 8751, 1, 0, 0, 0, 8752, 8753, 1, 0, + 0, 0, 8753, 507, 1, 0, 0, 0, 8754, 8761, 3, 356, 178, 0, 8755, 8760, 3, + 498, 249, 0, 8756, 8760, 3, 252, 126, 0, 8757, 8760, 3, 502, 251, 0, 8758, + 8760, 3, 1054, 527, 0, 8759, 8755, 1, 0, 0, 0, 8759, 8756, 1, 0, 0, 0, + 8759, 8757, 1, 0, 0, 0, 8759, 8758, 1, 0, 0, 0, 8760, 8763, 1, 0, 0, 0, + 8761, 8759, 1, 0, 0, 0, 8761, 8762, 1, 0, 0, 0, 8762, 8765, 1, 0, 0, 0, + 8763, 8761, 1, 0, 0, 0, 8764, 8766, 3, 496, 248, 0, 8765, 8764, 1, 0, 0, + 0, 8765, 8766, 1, 0, 0, 0, 8766, 8768, 1, 0, 0, 0, 8767, 8769, 3, 488, + 244, 0, 8768, 8767, 1, 0, 0, 0, 8768, 8769, 1, 0, 0, 0, 8769, 8772, 1, + 0, 0, 0, 8770, 8771, 5, 161, 0, 0, 8771, 8773, 3, 852, 426, 0, 8772, 8770, + 1, 0, 0, 0, 8772, 8773, 1, 0, 0, 0, 8773, 509, 1, 0, 0, 0, 8774, 8777, + 3, 508, 254, 0, 8775, 8777, 3, 506, 253, 0, 8776, 8774, 1, 0, 0, 0, 8776, + 8775, 1, 0, 0, 0, 8777, 511, 1, 0, 0, 0, 8778, 8783, 3, 510, 255, 0, 8779, + 8780, 5, 1110, 0, 0, 8780, 8782, 3, 510, 255, 0, 8781, 8779, 1, 0, 0, 0, + 8782, 8785, 1, 0, 0, 0, 8783, 8781, 1, 0, 0, 0, 8783, 8784, 1, 0, 0, 0, + 8784, 513, 1, 0, 0, 0, 8785, 8783, 1, 0, 0, 0, 8786, 8788, 5, 190, 0, 0, + 8787, 8789, 3, 654, 327, 0, 8788, 8787, 1, 0, 0, 0, 8788, 8789, 1, 0, 0, + 0, 8789, 8791, 1, 0, 0, 0, 8790, 8792, 3, 486, 243, 0, 8791, 8790, 1, 0, + 0, 0, 8791, 8792, 1, 0, 0, 0, 8792, 8793, 1, 0, 0, 0, 8793, 8802, 5, 880, + 0, 0, 8794, 8796, 3, 652, 326, 0, 8795, 8794, 1, 0, 0, 0, 8795, 8796, 1, + 0, 0, 0, 8796, 8797, 1, 0, 0, 0, 8797, 8803, 3, 878, 439, 0, 8798, 8800, + 3, 878, 439, 0, 8799, 8801, 3, 652, 326, 0, 8800, 8799, 1, 0, 0, 0, 8800, + 8801, 1, 0, 0, 0, 8801, 8803, 1, 0, 0, 0, 8802, 8795, 1, 0, 0, 0, 8802, + 8798, 1, 0, 0, 0, 8803, 8804, 1, 0, 0, 0, 8804, 8805, 5, 1104, 0, 0, 8805, + 8806, 3, 512, 256, 0, 8806, 8808, 5, 1105, 0, 0, 8807, 8809, 3, 492, 246, + 0, 8808, 8807, 1, 0, 0, 0, 8808, 8809, 1, 0, 0, 0, 8809, 8811, 1, 0, 0, + 0, 8810, 8812, 3, 50, 25, 0, 8811, 8810, 1, 0, 0, 0, 8811, 8812, 1, 0, + 0, 0, 8812, 8819, 1, 0, 0, 0, 8813, 8814, 5, 824, 0, 0, 8814, 8815, 5, + 1092, 0, 0, 8815, 8816, 5, 1104, 0, 0, 8816, 8817, 3, 428, 214, 0, 8817, + 8818, 5, 1105, 0, 0, 8818, 8820, 1, 0, 0, 0, 8819, 8813, 1, 0, 0, 0, 8819, + 8820, 1, 0, 0, 0, 8820, 8824, 1, 0, 0, 0, 8821, 8822, 5, 209, 0, 0, 8822, + 8823, 5, 1092, 0, 0, 8823, 8825, 3, 880, 440, 0, 8824, 8821, 1, 0, 0, 0, + 8824, 8825, 1, 0, 0, 0, 8825, 8829, 1, 0, 0, 0, 8826, 8827, 5, 467, 0, + 0, 8827, 8828, 5, 1092, 0, 0, 8828, 8830, 3, 880, 440, 0, 8829, 8826, 1, + 0, 0, 0, 8829, 8830, 1, 0, 0, 0, 8830, 8832, 1, 0, 0, 0, 8831, 8833, 3, + 494, 247, 0, 8832, 8831, 1, 0, 0, 0, 8832, 8833, 1, 0, 0, 0, 8833, 8835, + 1, 0, 0, 0, 8834, 8836, 3, 130, 65, 0, 8835, 8834, 1, 0, 0, 0, 8835, 8836, + 1, 0, 0, 0, 8836, 8838, 1, 0, 0, 0, 8837, 8839, 3, 472, 236, 0, 8838, 8837, + 1, 0, 0, 0, 8838, 8839, 1, 0, 0, 0, 8839, 8841, 1, 0, 0, 0, 8840, 8842, + 3, 490, 245, 0, 8841, 8840, 1, 0, 0, 0, 8841, 8842, 1, 0, 0, 0, 8842, 8844, + 1, 0, 0, 0, 8843, 8845, 3, 488, 244, 0, 8844, 8843, 1, 0, 0, 0, 8844, 8845, + 1, 0, 0, 0, 8845, 8847, 1, 0, 0, 0, 8846, 8848, 3, 646, 323, 0, 8847, 8846, + 1, 0, 0, 0, 8847, 8848, 1, 0, 0, 0, 8848, 515, 1, 0, 0, 0, 8849, 8851, + 5, 190, 0, 0, 8850, 8852, 3, 654, 327, 0, 8851, 8850, 1, 0, 0, 0, 8851, + 8852, 1, 0, 0, 0, 8852, 8854, 1, 0, 0, 0, 8853, 8855, 3, 486, 243, 0, 8854, + 8853, 1, 0, 0, 0, 8854, 8855, 1, 0, 0, 0, 8855, 8856, 1, 0, 0, 0, 8856, + 8865, 5, 880, 0, 0, 8857, 8859, 3, 652, 326, 0, 8858, 8857, 1, 0, 0, 0, + 8858, 8859, 1, 0, 0, 0, 8859, 8860, 1, 0, 0, 0, 8860, 8866, 3, 878, 439, + 0, 8861, 8863, 3, 878, 439, 0, 8862, 8864, 3, 652, 326, 0, 8863, 8862, + 1, 0, 0, 0, 8863, 8864, 1, 0, 0, 0, 8864, 8866, 1, 0, 0, 0, 8865, 8858, + 1, 0, 0, 0, 8865, 8861, 1, 0, 0, 0, 8866, 8871, 1, 0, 0, 0, 8867, 8868, + 5, 1104, 0, 0, 8868, 8869, 3, 512, 256, 0, 8869, 8870, 5, 1105, 0, 0, 8870, + 8872, 1, 0, 0, 0, 8871, 8867, 1, 0, 0, 0, 8871, 8872, 1, 0, 0, 0, 8872, + 8874, 1, 0, 0, 0, 8873, 8875, 3, 492, 246, 0, 8874, 8873, 1, 0, 0, 0, 8874, + 8875, 1, 0, 0, 0, 8875, 8877, 1, 0, 0, 0, 8876, 8878, 3, 472, 236, 0, 8877, + 8876, 1, 0, 0, 0, 8877, 8878, 1, 0, 0, 0, 8878, 8880, 1, 0, 0, 0, 8879, + 8881, 3, 490, 245, 0, 8880, 8879, 1, 0, 0, 0, 8880, 8881, 1, 0, 0, 0, 8881, + 8883, 1, 0, 0, 0, 8882, 8884, 3, 488, 244, 0, 8883, 8882, 1, 0, 0, 0, 8883, + 8884, 1, 0, 0, 0, 8884, 8886, 1, 0, 0, 0, 8885, 8887, 3, 646, 323, 0, 8886, + 8885, 1, 0, 0, 0, 8886, 8887, 1, 0, 0, 0, 8887, 8888, 1, 0, 0, 0, 8888, + 8889, 5, 56, 0, 0, 8889, 8890, 3, 942, 471, 0, 8890, 517, 1, 0, 0, 0, 8891, + 8893, 5, 190, 0, 0, 8892, 8894, 3, 654, 327, 0, 8893, 8892, 1, 0, 0, 0, + 8893, 8894, 1, 0, 0, 0, 8894, 8895, 1, 0, 0, 0, 8895, 8897, 5, 887, 0, + 0, 8896, 8898, 3, 652, 326, 0, 8897, 8896, 1, 0, 0, 0, 8897, 8898, 1, 0, + 0, 0, 8898, 8899, 1, 0, 0, 0, 8899, 8901, 3, 856, 428, 0, 8900, 8902, 3, + 646, 323, 0, 8901, 8900, 1, 0, 0, 0, 8901, 8902, 1, 0, 0, 0, 8902, 8924, + 1, 0, 0, 0, 8903, 8905, 5, 190, 0, 0, 8904, 8906, 3, 654, 327, 0, 8905, + 8904, 1, 0, 0, 0, 8905, 8906, 1, 0, 0, 0, 8906, 8907, 1, 0, 0, 0, 8907, + 8909, 5, 887, 0, 0, 8908, 8910, 3, 652, 326, 0, 8909, 8908, 1, 0, 0, 0, + 8909, 8910, 1, 0, 0, 0, 8910, 8911, 1, 0, 0, 0, 8911, 8921, 3, 856, 428, + 0, 8912, 8913, 5, 30, 0, 0, 8913, 8918, 3, 852, 426, 0, 8914, 8915, 5, + 1110, 0, 0, 8915, 8917, 3, 852, 426, 0, 8916, 8914, 1, 0, 0, 0, 8917, 8920, + 1, 0, 0, 0, 8918, 8916, 1, 0, 0, 0, 8918, 8919, 1, 0, 0, 0, 8919, 8922, + 1, 0, 0, 0, 8920, 8918, 1, 0, 0, 0, 8921, 8912, 1, 0, 0, 0, 8921, 8922, + 1, 0, 0, 0, 8922, 8924, 1, 0, 0, 0, 8923, 8891, 1, 0, 0, 0, 8923, 8903, + 1, 0, 0, 0, 8924, 519, 1, 0, 0, 0, 8925, 8926, 7, 53, 0, 0, 8926, 521, + 1, 0, 0, 0, 8927, 8932, 3, 520, 260, 0, 8928, 8929, 5, 1110, 0, 0, 8929, + 8931, 3, 520, 260, 0, 8930, 8928, 1, 0, 0, 0, 8931, 8934, 1, 0, 0, 0, 8932, + 8930, 1, 0, 0, 0, 8932, 8933, 1, 0, 0, 0, 8933, 523, 1, 0, 0, 0, 8934, + 8932, 1, 0, 0, 0, 8935, 8940, 3, 526, 263, 0, 8936, 8937, 5, 1110, 0, 0, + 8937, 8939, 3, 526, 263, 0, 8938, 8936, 1, 0, 0, 0, 8939, 8942, 1, 0, 0, + 0, 8940, 8938, 1, 0, 0, 0, 8940, 8941, 1, 0, 0, 0, 8941, 525, 1, 0, 0, + 0, 8942, 8940, 1, 0, 0, 0, 8943, 8944, 3, 520, 260, 0, 8944, 8945, 5, 1092, + 0, 0, 8945, 8946, 3, 450, 225, 0, 8946, 527, 1, 0, 0, 0, 8947, 8949, 5, + 190, 0, 0, 8948, 8950, 3, 654, 327, 0, 8949, 8948, 1, 0, 0, 0, 8949, 8950, + 1, 0, 0, 0, 8950, 8951, 1, 0, 0, 0, 8951, 8953, 5, 891, 0, 0, 8952, 8954, + 3, 652, 326, 0, 8953, 8952, 1, 0, 0, 0, 8953, 8954, 1, 0, 0, 0, 8954, 8955, + 1, 0, 0, 0, 8955, 8962, 3, 878, 439, 0, 8956, 8957, 5, 1011, 0, 0, 8957, + 8958, 5, 1092, 0, 0, 8958, 8963, 3, 852, 426, 0, 8959, 8960, 5, 988, 0, + 0, 8960, 8961, 5, 1092, 0, 0, 8961, 8963, 3, 852, 426, 0, 8962, 8956, 1, + 0, 0, 0, 8962, 8959, 1, 0, 0, 0, 8962, 8963, 1, 0, 0, 0, 8963, 8967, 1, + 0, 0, 0, 8964, 8965, 5, 755, 0, 0, 8965, 8966, 5, 1092, 0, 0, 8966, 8968, + 3, 852, 426, 0, 8967, 8964, 1, 0, 0, 0, 8967, 8968, 1, 0, 0, 0, 8968, 8972, + 1, 0, 0, 0, 8969, 8970, 5, 36, 0, 0, 8970, 8971, 5, 1092, 0, 0, 8971, 8973, + 3, 450, 225, 0, 8972, 8969, 1, 0, 0, 0, 8972, 8973, 1, 0, 0, 0, 8973, 8975, + 1, 0, 0, 0, 8974, 8976, 3, 524, 262, 0, 8975, 8974, 1, 0, 0, 0, 8975, 8976, + 1, 0, 0, 0, 8976, 8980, 1, 0, 0, 0, 8977, 8978, 5, 989, 0, 0, 8978, 8979, + 5, 1092, 0, 0, 8979, 8981, 3, 880, 440, 0, 8980, 8977, 1, 0, 0, 0, 8980, + 8981, 1, 0, 0, 0, 8981, 8985, 1, 0, 0, 0, 8982, 8983, 5, 873, 0, 0, 8983, + 8984, 5, 1092, 0, 0, 8984, 8986, 3, 880, 440, 0, 8985, 8982, 1, 0, 0, 0, + 8985, 8986, 1, 0, 0, 0, 8986, 8990, 1, 0, 0, 0, 8987, 8988, 5, 274, 0, + 0, 8988, 8989, 5, 1092, 0, 0, 8989, 8991, 3, 856, 428, 0, 8990, 8987, 1, + 0, 0, 0, 8990, 8991, 1, 0, 0, 0, 8991, 8993, 1, 0, 0, 0, 8992, 8994, 3, + 472, 236, 0, 8993, 8992, 1, 0, 0, 0, 8993, 8994, 1, 0, 0, 0, 8994, 8996, + 1, 0, 0, 0, 8995, 8997, 3, 646, 323, 0, 8996, 8995, 1, 0, 0, 0, 8996, 8997, + 1, 0, 0, 0, 8997, 9007, 1, 0, 0, 0, 8998, 8999, 5, 19, 0, 0, 8999, 9004, + 3, 852, 426, 0, 9000, 9001, 5, 1110, 0, 0, 9001, 9003, 3, 852, 426, 0, + 9002, 9000, 1, 0, 0, 0, 9003, 9006, 1, 0, 0, 0, 9004, 9002, 1, 0, 0, 0, + 9004, 9005, 1, 0, 0, 0, 9005, 9008, 1, 0, 0, 0, 9006, 9004, 1, 0, 0, 0, + 9007, 8998, 1, 0, 0, 0, 9007, 9008, 1, 0, 0, 0, 9008, 9011, 1, 0, 0, 0, + 9009, 9010, 5, 1018, 0, 0, 9010, 9012, 3, 1050, 525, 0, 9011, 9009, 1, + 0, 0, 0, 9011, 9012, 1, 0, 0, 0, 9012, 9013, 1, 0, 0, 0, 9013, 9014, 5, + 56, 0, 0, 9014, 9015, 3, 530, 265, 0, 9015, 529, 1, 0, 0, 0, 9016, 9020, + 3, 4, 2, 0, 9017, 9020, 3, 532, 266, 0, 9018, 9020, 5, 1082, 0, 0, 9019, + 9016, 1, 0, 0, 0, 9019, 9017, 1, 0, 0, 0, 9019, 9018, 1, 0, 0, 0, 9020, + 531, 1, 0, 0, 0, 9021, 9022, 5, 113, 0, 0, 9022, 9023, 3, 878, 439, 0, + 9023, 9025, 5, 1104, 0, 0, 9024, 9026, 3, 882, 441, 0, 9025, 9024, 1, 0, + 0, 0, 9025, 9026, 1, 0, 0, 0, 9026, 9027, 1, 0, 0, 0, 9027, 9028, 5, 1105, + 0, 0, 9028, 533, 1, 0, 0, 0, 9029, 9031, 5, 190, 0, 0, 9030, 9032, 3, 654, + 327, 0, 9031, 9030, 1, 0, 0, 0, 9031, 9032, 1, 0, 0, 0, 9032, 9033, 1, + 0, 0, 0, 9033, 9035, 5, 984, 0, 0, 9034, 9036, 3, 652, 326, 0, 9035, 9034, + 1, 0, 0, 0, 9035, 9036, 1, 0, 0, 0, 9036, 9037, 1, 0, 0, 0, 9037, 9039, + 3, 856, 428, 0, 9038, 9040, 3, 132, 66, 0, 9039, 9038, 1, 0, 0, 0, 9039, + 9040, 1, 0, 0, 0, 9040, 9042, 1, 0, 0, 0, 9041, 9043, 3, 128, 64, 0, 9042, + 9041, 1, 0, 0, 0, 9042, 9043, 1, 0, 0, 0, 9043, 9045, 1, 0, 0, 0, 9044, + 9046, 3, 134, 67, 0, 9045, 9044, 1, 0, 0, 0, 9045, 9046, 1, 0, 0, 0, 9046, + 535, 1, 0, 0, 0, 9047, 9048, 3, 874, 437, 0, 9048, 9049, 3, 496, 248, 0, + 9049, 9050, 3, 488, 244, 0, 9050, 537, 1, 0, 0, 0, 9051, 9053, 5, 190, + 0, 0, 9052, 9054, 3, 654, 327, 0, 9053, 9052, 1, 0, 0, 0, 9053, 9054, 1, + 0, 0, 0, 9054, 9056, 1, 0, 0, 0, 9055, 9057, 5, 769, 0, 0, 9056, 9055, + 1, 0, 0, 0, 9056, 9057, 1, 0, 0, 0, 9057, 9059, 1, 0, 0, 0, 9058, 9060, + 5, 667, 0, 0, 9059, 9058, 1, 0, 0, 0, 9059, 9060, 1, 0, 0, 0, 9060, 9061, + 1, 0, 0, 0, 9061, 9063, 5, 1005, 0, 0, 9062, 9064, 3, 652, 326, 0, 9063, + 9062, 1, 0, 0, 0, 9063, 9064, 1, 0, 0, 0, 9064, 9065, 1, 0, 0, 0, 9065, + 9070, 3, 878, 439, 0, 9066, 9067, 5, 1104, 0, 0, 9067, 9068, 3, 876, 438, + 0, 9068, 9069, 5, 1105, 0, 0, 9069, 9071, 1, 0, 0, 0, 9070, 9066, 1, 0, + 0, 0, 9070, 9071, 1, 0, 0, 0, 9071, 9075, 1, 0, 0, 0, 9072, 9074, 3, 536, + 268, 0, 9073, 9072, 1, 0, 0, 0, 9074, 9077, 1, 0, 0, 0, 9075, 9073, 1, + 0, 0, 0, 9075, 9076, 1, 0, 0, 0, 9076, 9079, 1, 0, 0, 0, 9077, 9075, 1, + 0, 0, 0, 9078, 9080, 3, 490, 245, 0, 9079, 9078, 1, 0, 0, 0, 9079, 9080, + 1, 0, 0, 0, 9080, 9082, 1, 0, 0, 0, 9081, 9083, 3, 488, 244, 0, 9082, 9081, + 1, 0, 0, 0, 9082, 9083, 1, 0, 0, 0, 9083, 9085, 1, 0, 0, 0, 9084, 9086, + 3, 472, 236, 0, 9085, 9084, 1, 0, 0, 0, 9085, 9086, 1, 0, 0, 0, 9086, 9088, + 1, 0, 0, 0, 9087, 9089, 3, 646, 323, 0, 9088, 9087, 1, 0, 0, 0, 9088, 9089, + 1, 0, 0, 0, 9089, 9090, 1, 0, 0, 0, 9090, 9091, 5, 56, 0, 0, 9091, 9092, + 3, 932, 466, 0, 9092, 539, 1, 0, 0, 0, 9093, 9095, 5, 190, 0, 0, 9094, + 9096, 3, 654, 327, 0, 9095, 9094, 1, 0, 0, 0, 9095, 9096, 1, 0, 0, 0, 9096, + 9097, 1, 0, 0, 0, 9097, 9099, 5, 1011, 0, 0, 9098, 9100, 3, 652, 326, 0, + 9099, 9098, 1, 0, 0, 0, 9099, 9100, 1, 0, 0, 0, 9100, 9101, 1, 0, 0, 0, + 9101, 9110, 3, 856, 428, 0, 9102, 9104, 5, 1020, 0, 0, 9103, 9102, 1, 0, + 0, 0, 9103, 9104, 1, 0, 0, 0, 9104, 9106, 1, 0, 0, 0, 9105, 9107, 3, 542, + 271, 0, 9106, 9105, 1, 0, 0, 0, 9107, 9108, 1, 0, 0, 0, 9108, 9106, 1, + 0, 0, 0, 9108, 9109, 1, 0, 0, 0, 9109, 9111, 1, 0, 0, 0, 9110, 9103, 1, + 0, 0, 0, 9110, 9111, 1, 0, 0, 0, 9111, 9115, 1, 0, 0, 0, 9112, 9114, 3, + 544, 272, 0, 9113, 9112, 1, 0, 0, 0, 9114, 9117, 1, 0, 0, 0, 9115, 9113, + 1, 0, 0, 0, 9115, 9116, 1, 0, 0, 0, 9116, 541, 1, 0, 0, 0, 9117, 9115, + 1, 0, 0, 0, 9118, 9119, 5, 1013, 0, 0, 9119, 9120, 5, 1092, 0, 0, 9120, + 9154, 7, 54, 0, 0, 9121, 9122, 5, 465, 0, 0, 9122, 9123, 5, 1092, 0, 0, + 9123, 9154, 3, 880, 440, 0, 9124, 9125, 5, 479, 0, 0, 9125, 9126, 5, 1092, + 0, 0, 9126, 9154, 3, 880, 440, 0, 9127, 9128, 5, 754, 0, 0, 9128, 9129, + 5, 1092, 0, 0, 9129, 9154, 5, 826, 0, 0, 9130, 9154, 5, 251, 0, 0, 9131, + 9135, 5, 72, 0, 0, 9132, 9133, 5, 1092, 0, 0, 9133, 9136, 3, 880, 440, + 0, 9134, 9136, 5, 522, 0, 0, 9135, 9132, 1, 0, 0, 0, 9135, 9134, 1, 0, + 0, 0, 9136, 9154, 1, 0, 0, 0, 9137, 9138, 5, 71, 0, 0, 9138, 9139, 5, 1092, + 0, 0, 9139, 9154, 3, 450, 225, 0, 9140, 9141, 5, 386, 0, 0, 9141, 9142, + 5, 1092, 0, 0, 9142, 9154, 3, 450, 225, 0, 9143, 9144, 5, 696, 0, 0, 9144, + 9145, 5, 1092, 0, 0, 9145, 9154, 3, 856, 428, 0, 9146, 9154, 3, 646, 323, + 0, 9147, 9148, 5, 262, 0, 0, 9148, 9149, 5, 1092, 0, 0, 9149, 9154, 3, + 450, 225, 0, 9150, 9151, 5, 643, 0, 0, 9151, 9152, 5, 1092, 0, 0, 9152, + 9154, 3, 880, 440, 0, 9153, 9118, 1, 0, 0, 0, 9153, 9121, 1, 0, 0, 0, 9153, + 9124, 1, 0, 0, 0, 9153, 9127, 1, 0, 0, 0, 9153, 9130, 1, 0, 0, 0, 9153, + 9131, 1, 0, 0, 0, 9153, 9137, 1, 0, 0, 0, 9153, 9140, 1, 0, 0, 0, 9153, + 9143, 1, 0, 0, 0, 9153, 9146, 1, 0, 0, 0, 9153, 9147, 1, 0, 0, 0, 9153, + 9150, 1, 0, 0, 0, 9154, 543, 1, 0, 0, 0, 9155, 9156, 5, 466, 0, 0, 9156, + 9157, 5, 1092, 0, 0, 9157, 9168, 3, 880, 440, 0, 9158, 9159, 5, 835, 0, + 0, 9159, 9160, 5, 1092, 0, 0, 9160, 9168, 3, 880, 440, 0, 9161, 9162, 5, + 836, 0, 0, 9162, 9163, 5, 1092, 0, 0, 9163, 9165, 3, 880, 440, 0, 9164, + 9166, 3, 488, 244, 0, 9165, 9164, 1, 0, 0, 0, 9165, 9166, 1, 0, 0, 0, 9166, + 9168, 1, 0, 0, 0, 9167, 9155, 1, 0, 0, 0, 9167, 9158, 1, 0, 0, 0, 9167, + 9161, 1, 0, 0, 0, 9168, 545, 1, 0, 0, 0, 9169, 9170, 5, 553, 0, 0, 9170, + 9171, 3, 880, 440, 0, 9171, 9172, 5, 592, 0, 0, 9172, 9173, 5, 246, 0, + 0, 9173, 9174, 7, 20, 0, 0, 9174, 547, 1, 0, 0, 0, 9175, 9203, 5, 718, + 0, 0, 9176, 9203, 5, 984, 0, 0, 9177, 9203, 5, 1011, 0, 0, 9178, 9203, + 5, 394, 0, 0, 9179, 9180, 5, 496, 0, 0, 9180, 9203, 5, 608, 0, 0, 9181, + 9182, 5, 779, 0, 0, 9182, 9203, 5, 608, 0, 0, 9183, 9203, 5, 207, 0, 0, + 9184, 9203, 5, 757, 0, 0, 9185, 9203, 5, 880, 0, 0, 9186, 9203, 5, 1005, + 0, 0, 9187, 9203, 5, 822, 0, 0, 9188, 9189, 5, 314, 0, 0, 9189, 9203, 5, + 325, 0, 0, 9190, 9203, 5, 857, 0, 0, 9191, 9203, 5, 891, 0, 0, 9192, 9193, + 5, 455, 0, 0, 9193, 9203, 5, 608, 0, 0, 9194, 9195, 5, 723, 0, 0, 9195, + 9196, 5, 8, 0, 0, 9196, 9203, 5, 608, 0, 0, 9197, 9203, 5, 887, 0, 0, 9198, + 9203, 5, 601, 0, 0, 9199, 9203, 5, 331, 0, 0, 9200, 9203, 5, 628, 0, 0, + 9201, 9203, 5, 775, 0, 0, 9202, 9175, 1, 0, 0, 0, 9202, 9176, 1, 0, 0, + 0, 9202, 9177, 1, 0, 0, 0, 9202, 9178, 1, 0, 0, 0, 9202, 9179, 1, 0, 0, + 0, 9202, 9181, 1, 0, 0, 0, 9202, 9183, 1, 0, 0, 0, 9202, 9184, 1, 0, 0, + 0, 9202, 9185, 1, 0, 0, 0, 9202, 9186, 1, 0, 0, 0, 9202, 9187, 1, 0, 0, + 0, 9202, 9188, 1, 0, 0, 0, 9202, 9190, 1, 0, 0, 0, 9202, 9191, 1, 0, 0, + 0, 9202, 9192, 1, 0, 0, 0, 9202, 9194, 1, 0, 0, 0, 9202, 9197, 1, 0, 0, + 0, 9202, 9198, 1, 0, 0, 0, 9202, 9199, 1, 0, 0, 0, 9202, 9200, 1, 0, 0, + 0, 9202, 9201, 1, 0, 0, 0, 9203, 549, 1, 0, 0, 0, 9204, 9205, 7, 55, 0, + 0, 9205, 551, 1, 0, 0, 0, 9206, 9239, 3, 554, 277, 0, 9207, 9239, 3, 556, + 278, 0, 9208, 9239, 3, 558, 279, 0, 9209, 9239, 3, 560, 280, 0, 9210, 9239, + 3, 562, 281, 0, 9211, 9239, 3, 564, 282, 0, 9212, 9239, 3, 566, 283, 0, + 9213, 9239, 3, 568, 284, 0, 9214, 9239, 3, 570, 285, 0, 9215, 9239, 3, + 572, 286, 0, 9216, 9239, 3, 574, 287, 0, 9217, 9239, 3, 576, 288, 0, 9218, + 9239, 3, 578, 289, 0, 9219, 9239, 3, 580, 290, 0, 9220, 9239, 3, 582, 291, + 0, 9221, 9239, 3, 584, 292, 0, 9222, 9239, 3, 586, 293, 0, 9223, 9239, + 3, 588, 294, 0, 9224, 9239, 3, 590, 295, 0, 9225, 9239, 3, 592, 296, 0, + 9226, 9239, 3, 594, 297, 0, 9227, 9239, 3, 596, 298, 0, 9228, 9239, 3, + 598, 299, 0, 9229, 9239, 3, 600, 300, 0, 9230, 9239, 3, 602, 301, 0, 9231, + 9239, 3, 604, 302, 0, 9232, 9239, 3, 606, 303, 0, 9233, 9239, 3, 608, 304, + 0, 9234, 9239, 3, 610, 305, 0, 9235, 9239, 3, 612, 306, 0, 9236, 9239, + 3, 614, 307, 0, 9237, 9239, 3, 616, 308, 0, 9238, 9206, 1, 0, 0, 0, 9238, + 9207, 1, 0, 0, 0, 9238, 9208, 1, 0, 0, 0, 9238, 9209, 1, 0, 0, 0, 9238, + 9210, 1, 0, 0, 0, 9238, 9211, 1, 0, 0, 0, 9238, 9212, 1, 0, 0, 0, 9238, + 9213, 1, 0, 0, 0, 9238, 9214, 1, 0, 0, 0, 9238, 9215, 1, 0, 0, 0, 9238, + 9216, 1, 0, 0, 0, 9238, 9217, 1, 0, 0, 0, 9238, 9218, 1, 0, 0, 0, 9238, + 9219, 1, 0, 0, 0, 9238, 9220, 1, 0, 0, 0, 9238, 9221, 1, 0, 0, 0, 9238, + 9222, 1, 0, 0, 0, 9238, 9223, 1, 0, 0, 0, 9238, 9224, 1, 0, 0, 0, 9238, + 9225, 1, 0, 0, 0, 9238, 9226, 1, 0, 0, 0, 9238, 9227, 1, 0, 0, 0, 9238, + 9228, 1, 0, 0, 0, 9238, 9229, 1, 0, 0, 0, 9238, 9230, 1, 0, 0, 0, 9238, + 9231, 1, 0, 0, 0, 9238, 9232, 1, 0, 0, 0, 9238, 9233, 1, 0, 0, 0, 9238, + 9234, 1, 0, 0, 0, 9238, 9235, 1, 0, 0, 0, 9238, 9236, 1, 0, 0, 0, 9238, + 9237, 1, 0, 0, 0, 9239, 553, 1, 0, 0, 0, 9240, 9241, 5, 249, 0, 0, 9241, + 9242, 3, 836, 418, 0, 9242, 9243, 3, 650, 325, 0, 9243, 9245, 3, 856, 428, + 0, 9244, 9246, 3, 618, 309, 0, 9245, 9244, 1, 0, 0, 0, 9245, 9246, 1, 0, + 0, 0, 9246, 555, 1, 0, 0, 0, 9247, 9248, 5, 249, 0, 0, 9248, 9249, 5, 21, + 0, 0, 9249, 9250, 3, 856, 428, 0, 9250, 557, 1, 0, 0, 0, 9251, 9252, 5, + 249, 0, 0, 9252, 9254, 5, 172, 0, 0, 9253, 9255, 3, 650, 325, 0, 9254, + 9253, 1, 0, 0, 0, 9254, 9255, 1, 0, 0, 0, 9255, 9256, 1, 0, 0, 0, 9256, + 9257, 3, 856, 428, 0, 9257, 559, 1, 0, 0, 0, 9258, 9259, 5, 249, 0, 0, + 9259, 9261, 5, 207, 0, 0, 9260, 9262, 3, 650, 325, 0, 9261, 9260, 1, 0, + 0, 0, 9261, 9262, 1, 0, 0, 0, 9262, 9263, 1, 0, 0, 0, 9263, 9265, 3, 856, + 428, 0, 9264, 9266, 3, 618, 309, 0, 9265, 9264, 1, 0, 0, 0, 9265, 9266, + 1, 0, 0, 0, 9266, 561, 1, 0, 0, 0, 9267, 9268, 5, 249, 0, 0, 9268, 9269, + 5, 250, 0, 0, 9269, 9271, 5, 880, 0, 0, 9270, 9272, 3, 650, 325, 0, 9271, + 9270, 1, 0, 0, 0, 9271, 9272, 1, 0, 0, 0, 9272, 9273, 1, 0, 0, 0, 9273, + 9274, 3, 856, 428, 0, 9274, 563, 1, 0, 0, 0, 9275, 9276, 5, 249, 0, 0, + 9276, 9277, 5, 291, 0, 0, 9277, 9279, 5, 880, 0, 0, 9278, 9280, 3, 650, + 325, 0, 9279, 9278, 1, 0, 0, 0, 9279, 9280, 1, 0, 0, 0, 9280, 9281, 1, + 0, 0, 0, 9281, 9283, 3, 878, 439, 0, 9282, 9284, 3, 618, 309, 0, 9283, + 9282, 1, 0, 0, 0, 9283, 9284, 1, 0, 0, 0, 9284, 565, 1, 0, 0, 0, 9285, + 9286, 5, 249, 0, 0, 9286, 9287, 5, 307, 0, 0, 9287, 9289, 5, 350, 0, 0, + 9288, 9290, 3, 650, 325, 0, 9289, 9288, 1, 0, 0, 0, 9289, 9290, 1, 0, 0, + 0, 9290, 9291, 1, 0, 0, 0, 9291, 9292, 3, 856, 428, 0, 9292, 567, 1, 0, + 0, 0, 9293, 9294, 5, 249, 0, 0, 9294, 9295, 5, 314, 0, 0, 9295, 9297, 5, + 325, 0, 0, 9296, 9298, 3, 650, 325, 0, 9297, 9296, 1, 0, 0, 0, 9297, 9298, + 1, 0, 0, 0, 9298, 9299, 1, 0, 0, 0, 9299, 9300, 3, 856, 428, 0, 9300, 569, + 1, 0, 0, 0, 9301, 9302, 5, 249, 0, 0, 9302, 9304, 5, 331, 0, 0, 9303, 9305, + 3, 650, 325, 0, 9304, 9303, 1, 0, 0, 0, 9304, 9305, 1, 0, 0, 0, 9305, 9306, + 1, 0, 0, 0, 9306, 9307, 3, 878, 439, 0, 9307, 9308, 3, 620, 310, 0, 9308, + 571, 1, 0, 0, 0, 9309, 9311, 5, 249, 0, 0, 9310, 9312, 7, 56, 0, 0, 9311, + 9310, 1, 0, 0, 0, 9311, 9312, 1, 0, 0, 0, 9312, 9313, 1, 0, 0, 0, 9313, + 9315, 5, 394, 0, 0, 9314, 9316, 3, 650, 325, 0, 9315, 9314, 1, 0, 0, 0, + 9315, 9316, 1, 0, 0, 0, 9316, 9317, 1, 0, 0, 0, 9317, 9318, 3, 856, 428, + 0, 9318, 573, 1, 0, 0, 0, 9319, 9320, 5, 249, 0, 0, 9320, 9321, 5, 452, + 0, 0, 9321, 9322, 5, 9, 0, 0, 9322, 9323, 3, 856, 428, 0, 9323, 575, 1, + 0, 0, 0, 9324, 9325, 5, 249, 0, 0, 9325, 9326, 5, 455, 0, 0, 9326, 9327, + 5, 608, 0, 0, 9327, 9328, 3, 856, 428, 0, 9328, 577, 1, 0, 0, 0, 9329, + 9330, 5, 249, 0, 0, 9330, 9331, 5, 463, 0, 0, 9331, 9333, 5, 1005, 0, 0, + 9332, 9334, 3, 650, 325, 0, 9333, 9332, 1, 0, 0, 0, 9333, 9334, 1, 0, 0, + 0, 9334, 9335, 1, 0, 0, 0, 9335, 9336, 3, 878, 439, 0, 9336, 579, 1, 0, + 0, 0, 9337, 9338, 5, 249, 0, 0, 9338, 9339, 5, 496, 0, 0, 9339, 9341, 5, + 608, 0, 0, 9340, 9342, 3, 650, 325, 0, 9341, 9340, 1, 0, 0, 0, 9341, 9342, + 1, 0, 0, 0, 9342, 9343, 1, 0, 0, 0, 9343, 9344, 3, 856, 428, 0, 9344, 581, + 1, 0, 0, 0, 9345, 9346, 5, 249, 0, 0, 9346, 9348, 5, 601, 0, 0, 9347, 9349, + 3, 650, 325, 0, 9348, 9347, 1, 0, 0, 0, 9348, 9349, 1, 0, 0, 0, 9349, 9350, + 1, 0, 0, 0, 9350, 9351, 3, 878, 439, 0, 9351, 583, 1, 0, 0, 0, 9352, 9353, + 5, 249, 0, 0, 9353, 9355, 5, 628, 0, 0, 9354, 9356, 3, 650, 325, 0, 9355, + 9354, 1, 0, 0, 0, 9355, 9356, 1, 0, 0, 0, 9356, 9357, 1, 0, 0, 0, 9357, + 9358, 3, 878, 439, 0, 9358, 9359, 3, 620, 310, 0, 9359, 585, 1, 0, 0, 0, + 9360, 9361, 5, 249, 0, 0, 9361, 9362, 5, 687, 0, 0, 9362, 9364, 5, 350, + 0, 0, 9363, 9365, 3, 650, 325, 0, 9364, 9363, 1, 0, 0, 0, 9364, 9365, 1, + 0, 0, 0, 9365, 9366, 1, 0, 0, 0, 9366, 9367, 3, 856, 428, 0, 9367, 587, + 1, 0, 0, 0, 9368, 9369, 5, 249, 0, 0, 9369, 9370, 5, 694, 0, 0, 9370, 9371, + 5, 484, 0, 0, 9371, 9372, 3, 856, 428, 0, 9372, 589, 1, 0, 0, 0, 9373, + 9374, 5, 249, 0, 0, 9374, 9376, 5, 718, 0, 0, 9375, 9377, 3, 650, 325, + 0, 9376, 9375, 1, 0, 0, 0, 9376, 9377, 1, 0, 0, 0, 9377, 9378, 1, 0, 0, + 0, 9378, 9379, 3, 856, 428, 0, 9379, 591, 1, 0, 0, 0, 9380, 9381, 5, 249, + 0, 0, 9381, 9382, 5, 723, 0, 0, 9382, 9383, 5, 8, 0, 0, 9383, 9385, 5, + 608, 0, 0, 9384, 9386, 3, 650, 325, 0, 9385, 9384, 1, 0, 0, 0, 9385, 9386, + 1, 0, 0, 0, 9386, 9387, 1, 0, 0, 0, 9387, 9388, 3, 856, 428, 0, 9388, 593, + 1, 0, 0, 0, 9389, 9390, 5, 249, 0, 0, 9390, 9392, 5, 757, 0, 0, 9391, 9393, + 3, 650, 325, 0, 9392, 9391, 1, 0, 0, 0, 9392, 9393, 1, 0, 0, 0, 9393, 9394, + 1, 0, 0, 0, 9394, 9396, 3, 834, 417, 0, 9395, 9397, 3, 618, 309, 0, 9396, + 9395, 1, 0, 0, 0, 9396, 9397, 1, 0, 0, 0, 9397, 595, 1, 0, 0, 0, 9398, + 9399, 5, 249, 0, 0, 9399, 9401, 5, 775, 0, 0, 9400, 9402, 3, 650, 325, + 0, 9401, 9400, 1, 0, 0, 0, 9401, 9402, 1, 0, 0, 0, 9402, 9403, 1, 0, 0, + 0, 9403, 9405, 3, 878, 439, 0, 9404, 9406, 3, 618, 309, 0, 9405, 9404, + 1, 0, 0, 0, 9405, 9406, 1, 0, 0, 0, 9406, 597, 1, 0, 0, 0, 9407, 9408, + 5, 249, 0, 0, 9408, 9409, 5, 779, 0, 0, 9409, 9411, 5, 608, 0, 0, 9410, + 9412, 3, 650, 325, 0, 9411, 9410, 1, 0, 0, 0, 9411, 9412, 1, 0, 0, 0, 9412, + 9413, 1, 0, 0, 0, 9413, 9414, 3, 856, 428, 0, 9414, 599, 1, 0, 0, 0, 9415, + 9416, 5, 249, 0, 0, 9416, 9417, 5, 786, 0, 0, 9417, 9418, 3, 856, 428, + 0, 9418, 601, 1, 0, 0, 0, 9419, 9420, 5, 249, 0, 0, 9420, 9422, 5, 822, + 0, 0, 9421, 9423, 3, 650, 325, 0, 9422, 9421, 1, 0, 0, 0, 9422, 9423, 1, + 0, 0, 0, 9423, 9424, 1, 0, 0, 0, 9424, 9425, 3, 878, 439, 0, 9425, 603, + 1, 0, 0, 0, 9426, 9427, 5, 249, 0, 0, 9427, 9429, 5, 857, 0, 0, 9428, 9430, + 3, 650, 325, 0, 9429, 9428, 1, 0, 0, 0, 9429, 9430, 1, 0, 0, 0, 9430, 9431, + 1, 0, 0, 0, 9431, 9432, 3, 878, 439, 0, 9432, 605, 1, 0, 0, 0, 9433, 9434, + 5, 249, 0, 0, 9434, 9436, 5, 880, 0, 0, 9435, 9437, 3, 650, 325, 0, 9436, + 9435, 1, 0, 0, 0, 9436, 9437, 1, 0, 0, 0, 9437, 9438, 1, 0, 0, 0, 9438, + 9440, 3, 878, 439, 0, 9439, 9441, 3, 618, 309, 0, 9440, 9439, 1, 0, 0, + 0, 9440, 9441, 1, 0, 0, 0, 9441, 607, 1, 0, 0, 0, 9442, 9443, 5, 249, 0, + 0, 9443, 9445, 5, 887, 0, 0, 9444, 9446, 3, 650, 325, 0, 9445, 9444, 1, + 0, 0, 0, 9445, 9446, 1, 0, 0, 0, 9446, 9447, 1, 0, 0, 0, 9447, 9448, 3, + 856, 428, 0, 9448, 609, 1, 0, 0, 0, 9449, 9450, 5, 249, 0, 0, 9450, 9452, + 5, 891, 0, 0, 9451, 9453, 3, 650, 325, 0, 9452, 9451, 1, 0, 0, 0, 9452, + 9453, 1, 0, 0, 0, 9453, 9454, 1, 0, 0, 0, 9454, 9455, 3, 878, 439, 0, 9455, + 611, 1, 0, 0, 0, 9456, 9457, 5, 249, 0, 0, 9457, 9459, 5, 984, 0, 0, 9458, + 9460, 3, 650, 325, 0, 9459, 9458, 1, 0, 0, 0, 9459, 9460, 1, 0, 0, 0, 9460, + 9461, 1, 0, 0, 0, 9461, 9462, 3, 856, 428, 0, 9462, 613, 1, 0, 0, 0, 9463, + 9464, 5, 249, 0, 0, 9464, 9466, 5, 1005, 0, 0, 9465, 9467, 3, 650, 325, + 0, 9466, 9465, 1, 0, 0, 0, 9466, 9467, 1, 0, 0, 0, 9467, 9468, 1, 0, 0, + 0, 9468, 9469, 3, 878, 439, 0, 9469, 615, 1, 0, 0, 0, 9470, 9471, 5, 249, + 0, 0, 9471, 9473, 5, 1011, 0, 0, 9472, 9474, 3, 650, 325, 0, 9473, 9472, + 1, 0, 0, 0, 9473, 9474, 1, 0, 0, 0, 9474, 9475, 1, 0, 0, 0, 9475, 9476, + 3, 856, 428, 0, 9476, 617, 1, 0, 0, 0, 9477, 9478, 7, 57, 0, 0, 9478, 619, + 1, 0, 0, 0, 9479, 9481, 5, 1104, 0, 0, 9480, 9482, 3, 182, 91, 0, 9481, + 9480, 1, 0, 0, 0, 9481, 9482, 1, 0, 0, 0, 9482, 9483, 1, 0, 0, 0, 9483, + 9484, 5, 1105, 0, 0, 9484, 621, 1, 0, 0, 0, 9485, 9491, 3, 624, 312, 0, + 9486, 9491, 3, 626, 313, 0, 9487, 9491, 3, 628, 314, 0, 9488, 9491, 3, + 630, 315, 0, 9489, 9491, 3, 632, 316, 0, 9490, 9485, 1, 0, 0, 0, 9490, + 9486, 1, 0, 0, 0, 9490, 9487, 1, 0, 0, 0, 9490, 9488, 1, 0, 0, 0, 9490, + 9489, 1, 0, 0, 0, 9491, 623, 1, 0, 0, 0, 9492, 9493, 5, 963, 0, 0, 9493, + 9494, 5, 207, 0, 0, 9494, 9495, 3, 856, 428, 0, 9495, 625, 1, 0, 0, 0, + 9496, 9497, 5, 963, 0, 0, 9497, 9498, 5, 250, 0, 0, 9498, 9499, 5, 880, + 0, 0, 9499, 9500, 3, 856, 428, 0, 9500, 627, 1, 0, 0, 0, 9501, 9502, 5, + 963, 0, 0, 9502, 9503, 5, 757, 0, 0, 9503, 9504, 3, 834, 417, 0, 9504, + 629, 1, 0, 0, 0, 9505, 9506, 5, 963, 0, 0, 9506, 9507, 5, 880, 0, 0, 9507, + 9508, 3, 878, 439, 0, 9508, 631, 1, 0, 0, 0, 9509, 9510, 5, 963, 0, 0, + 9510, 9511, 5, 887, 0, 0, 9511, 9512, 3, 856, 428, 0, 9512, 633, 1, 0, + 0, 0, 9513, 9519, 3, 636, 318, 0, 9514, 9519, 3, 638, 319, 0, 9515, 9519, + 3, 640, 320, 0, 9516, 9519, 3, 642, 321, 0, 9517, 9519, 3, 644, 322, 0, + 9518, 9513, 1, 0, 0, 0, 9518, 9514, 1, 0, 0, 0, 9518, 9515, 1, 0, 0, 0, + 9518, 9516, 1, 0, 0, 0, 9518, 9517, 1, 0, 0, 0, 9519, 635, 1, 0, 0, 0, + 9520, 9521, 5, 982, 0, 0, 9521, 9522, 5, 207, 0, 0, 9522, 9523, 3, 856, + 428, 0, 9523, 637, 1, 0, 0, 0, 9524, 9525, 5, 982, 0, 0, 9525, 9526, 5, + 718, 0, 0, 9526, 9527, 3, 856, 428, 0, 9527, 639, 1, 0, 0, 0, 9528, 9530, + 5, 982, 0, 0, 9529, 9531, 5, 757, 0, 0, 9530, 9529, 1, 0, 0, 0, 9530, 9531, + 1, 0, 0, 0, 9531, 9535, 1, 0, 0, 0, 9532, 9533, 3, 856, 428, 0, 9533, 9534, + 5, 1099, 0, 0, 9534, 9536, 1, 0, 0, 0, 9535, 9532, 1, 0, 0, 0, 9535, 9536, + 1, 0, 0, 0, 9536, 9537, 1, 0, 0, 0, 9537, 9538, 3, 856, 428, 0, 9538, 641, + 1, 0, 0, 0, 9539, 9540, 5, 982, 0, 0, 9540, 9541, 5, 764, 0, 0, 9541, 9542, + 5, 719, 0, 0, 9542, 9543, 7, 58, 0, 0, 9543, 643, 1, 0, 0, 0, 9544, 9545, + 5, 982, 0, 0, 9545, 9546, 5, 1011, 0, 0, 9546, 9547, 3, 856, 428, 0, 9547, + 645, 1, 0, 0, 0, 9548, 9549, 5, 161, 0, 0, 9549, 9550, 5, 1092, 0, 0, 9550, + 9551, 3, 852, 426, 0, 9551, 647, 1, 0, 0, 0, 9552, 9553, 5, 364, 0, 0, + 9553, 9554, 5, 871, 0, 0, 9554, 649, 1, 0, 0, 0, 9555, 9556, 5, 364, 0, + 0, 9556, 9557, 5, 285, 0, 0, 9557, 651, 1, 0, 0, 0, 9558, 9559, 5, 364, + 0, 0, 9559, 9560, 5, 511, 0, 0, 9560, 9561, 5, 285, 0, 0, 9561, 653, 1, + 0, 0, 0, 9562, 9563, 5, 564, 0, 0, 9563, 9564, 5, 684, 0, 0, 9564, 655, + 1, 0, 0, 0, 9565, 9566, 7, 59, 0, 0, 9566, 657, 1, 0, 0, 0, 9567, 9595, + 3, 660, 330, 0, 9568, 9595, 3, 662, 331, 0, 9569, 9595, 3, 664, 332, 0, + 9570, 9595, 3, 666, 333, 0, 9571, 9595, 3, 668, 334, 0, 9572, 9595, 3, + 670, 335, 0, 9573, 9595, 3, 672, 336, 0, 9574, 9595, 3, 674, 337, 0, 9575, + 9595, 3, 676, 338, 0, 9576, 9595, 3, 678, 339, 0, 9577, 9595, 3, 680, 340, + 0, 9578, 9595, 3, 682, 341, 0, 9579, 9595, 3, 684, 342, 0, 9580, 9595, + 3, 686, 343, 0, 9581, 9595, 3, 688, 344, 0, 9582, 9595, 3, 690, 345, 0, + 9583, 9595, 3, 692, 346, 0, 9584, 9595, 3, 694, 347, 0, 9585, 9595, 3, + 696, 348, 0, 9586, 9595, 3, 698, 349, 0, 9587, 9595, 3, 700, 350, 0, 9588, + 9595, 3, 702, 351, 0, 9589, 9595, 3, 704, 352, 0, 9590, 9595, 3, 706, 353, + 0, 9591, 9595, 3, 708, 354, 0, 9592, 9595, 3, 710, 355, 0, 9593, 9595, + 3, 712, 356, 0, 9594, 9567, 1, 0, 0, 0, 9594, 9568, 1, 0, 0, 0, 9594, 9569, + 1, 0, 0, 0, 9594, 9570, 1, 0, 0, 0, 9594, 9571, 1, 0, 0, 0, 9594, 9572, + 1, 0, 0, 0, 9594, 9573, 1, 0, 0, 0, 9594, 9574, 1, 0, 0, 0, 9594, 9575, + 1, 0, 0, 0, 9594, 9576, 1, 0, 0, 0, 9594, 9577, 1, 0, 0, 0, 9594, 9578, + 1, 0, 0, 0, 9594, 9579, 1, 0, 0, 0, 9594, 9580, 1, 0, 0, 0, 9594, 9581, + 1, 0, 0, 0, 9594, 9582, 1, 0, 0, 0, 9594, 9583, 1, 0, 0, 0, 9594, 9584, + 1, 0, 0, 0, 9594, 9585, 1, 0, 0, 0, 9594, 9586, 1, 0, 0, 0, 9594, 9587, + 1, 0, 0, 0, 9594, 9588, 1, 0, 0, 0, 9594, 9589, 1, 0, 0, 0, 9594, 9590, + 1, 0, 0, 0, 9594, 9591, 1, 0, 0, 0, 9594, 9592, 1, 0, 0, 0, 9594, 9593, + 1, 0, 0, 0, 9595, 659, 1, 0, 0, 0, 9596, 9597, 3, 656, 328, 0, 9597, 9598, + 5, 21, 0, 0, 9598, 9599, 3, 856, 428, 0, 9599, 661, 1, 0, 0, 0, 9600, 9601, + 3, 656, 328, 0, 9601, 9602, 5, 207, 0, 0, 9602, 9603, 3, 856, 428, 0, 9603, + 663, 1, 0, 0, 0, 9604, 9605, 3, 656, 328, 0, 9605, 9606, 5, 250, 0, 0, + 9606, 9607, 5, 880, 0, 0, 9607, 9608, 3, 856, 428, 0, 9608, 665, 1, 0, + 0, 0, 9609, 9611, 3, 656, 328, 0, 9610, 9612, 5, 291, 0, 0, 9611, 9610, + 1, 0, 0, 0, 9611, 9612, 1, 0, 0, 0, 9612, 9613, 1, 0, 0, 0, 9613, 9614, + 5, 880, 0, 0, 9614, 9618, 3, 878, 439, 0, 9615, 9616, 5, 954, 0, 0, 9616, + 9617, 5, 1092, 0, 0, 9617, 9619, 7, 60, 0, 0, 9618, 9615, 1, 0, 0, 0, 9618, + 9619, 1, 0, 0, 0, 9619, 667, 1, 0, 0, 0, 9620, 9621, 3, 656, 328, 0, 9621, + 9622, 5, 314, 0, 0, 9622, 9623, 5, 325, 0, 0, 9623, 9624, 3, 856, 428, + 0, 9624, 669, 1, 0, 0, 0, 9625, 9626, 3, 656, 328, 0, 9626, 9627, 5, 331, + 0, 0, 9627, 9628, 3, 878, 439, 0, 9628, 9629, 3, 620, 310, 0, 9629, 671, + 1, 0, 0, 0, 9630, 9632, 3, 656, 328, 0, 9631, 9633, 7, 56, 0, 0, 9632, + 9631, 1, 0, 0, 0, 9632, 9633, 1, 0, 0, 0, 9633, 9634, 1, 0, 0, 0, 9634, + 9635, 5, 394, 0, 0, 9635, 9636, 3, 856, 428, 0, 9636, 673, 1, 0, 0, 0, + 9637, 9638, 3, 656, 328, 0, 9638, 9639, 5, 455, 0, 0, 9639, 9640, 5, 608, + 0, 0, 9640, 9641, 3, 856, 428, 0, 9641, 675, 1, 0, 0, 0, 9642, 9643, 3, + 656, 328, 0, 9643, 9644, 5, 463, 0, 0, 9644, 9645, 5, 1005, 0, 0, 9645, + 9646, 3, 878, 439, 0, 9646, 677, 1, 0, 0, 0, 9647, 9648, 3, 656, 328, 0, + 9648, 9649, 5, 496, 0, 0, 9649, 9650, 5, 608, 0, 0, 9650, 9651, 3, 856, + 428, 0, 9651, 679, 1, 0, 0, 0, 9652, 9653, 3, 656, 328, 0, 9653, 9654, + 5, 601, 0, 0, 9654, 9655, 3, 878, 439, 0, 9655, 681, 1, 0, 0, 0, 9656, + 9657, 3, 656, 328, 0, 9657, 9658, 5, 628, 0, 0, 9658, 9659, 3, 878, 439, + 0, 9659, 9660, 3, 620, 310, 0, 9660, 683, 1, 0, 0, 0, 9661, 9662, 3, 656, + 328, 0, 9662, 9667, 5, 702, 0, 0, 9663, 9668, 5, 1083, 0, 0, 9664, 9665, + 5, 422, 0, 0, 9665, 9666, 5, 1104, 0, 0, 9666, 9668, 5, 1105, 0, 0, 9667, + 9663, 1, 0, 0, 0, 9667, 9664, 1, 0, 0, 0, 9668, 685, 1, 0, 0, 0, 9669, + 9670, 3, 656, 328, 0, 9670, 9671, 5, 723, 0, 0, 9671, 9672, 5, 8, 0, 0, + 9672, 9673, 5, 608, 0, 0, 9673, 9674, 3, 856, 428, 0, 9674, 687, 1, 0, + 0, 0, 9675, 9676, 3, 656, 328, 0, 9676, 9677, 5, 757, 0, 0, 9677, 9678, + 3, 834, 417, 0, 9678, 689, 1, 0, 0, 0, 9679, 9680, 3, 656, 328, 0, 9680, + 9681, 5, 763, 0, 0, 9681, 9682, 5, 562, 0, 0, 9682, 9683, 5, 553, 0, 0, + 9683, 9684, 3, 878, 439, 0, 9684, 691, 1, 0, 0, 0, 9685, 9686, 3, 656, + 328, 0, 9686, 9687, 5, 775, 0, 0, 9687, 9688, 3, 878, 439, 0, 9688, 693, + 1, 0, 0, 0, 9689, 9690, 3, 656, 328, 0, 9690, 9691, 5, 779, 0, 0, 9691, + 9692, 5, 608, 0, 0, 9692, 9693, 3, 856, 428, 0, 9693, 695, 1, 0, 0, 0, + 9694, 9695, 3, 656, 328, 0, 9695, 9696, 5, 786, 0, 0, 9696, 9697, 3, 856, + 428, 0, 9697, 697, 1, 0, 0, 0, 9698, 9699, 3, 656, 328, 0, 9699, 9700, + 5, 822, 0, 0, 9700, 9701, 3, 878, 439, 0, 9701, 699, 1, 0, 0, 0, 9702, + 9703, 3, 656, 328, 0, 9703, 9704, 5, 857, 0, 0, 9704, 9705, 3, 878, 439, + 0, 9705, 701, 1, 0, 0, 0, 9706, 9707, 3, 656, 328, 0, 9707, 9708, 5, 880, + 0, 0, 9708, 9712, 3, 878, 439, 0, 9709, 9710, 5, 954, 0, 0, 9710, 9711, + 5, 1092, 0, 0, 9711, 9713, 7, 60, 0, 0, 9712, 9709, 1, 0, 0, 0, 9712, 9713, + 1, 0, 0, 0, 9713, 703, 1, 0, 0, 0, 9714, 9715, 3, 656, 328, 0, 9715, 9716, + 5, 891, 0, 0, 9716, 9717, 3, 878, 439, 0, 9717, 705, 1, 0, 0, 0, 9718, + 9719, 3, 656, 328, 0, 9719, 9720, 5, 930, 0, 0, 9720, 9721, 3, 880, 440, + 0, 9721, 707, 1, 0, 0, 0, 9722, 9723, 3, 656, 328, 0, 9723, 9724, 5, 984, + 0, 0, 9724, 9725, 3, 856, 428, 0, 9725, 709, 1, 0, 0, 0, 9726, 9727, 3, + 656, 328, 0, 9727, 9728, 5, 1005, 0, 0, 9728, 9729, 3, 878, 439, 0, 9729, + 711, 1, 0, 0, 0, 9730, 9731, 3, 656, 328, 0, 9731, 9732, 5, 1011, 0, 0, + 9732, 9733, 3, 856, 428, 0, 9733, 713, 1, 0, 0, 0, 9734, 9786, 3, 716, + 358, 0, 9735, 9786, 3, 718, 359, 0, 9736, 9786, 3, 720, 360, 0, 9737, 9786, + 3, 726, 363, 0, 9738, 9786, 3, 728, 364, 0, 9739, 9786, 3, 730, 365, 0, + 9740, 9786, 3, 732, 366, 0, 9741, 9786, 3, 734, 367, 0, 9742, 9786, 3, + 736, 368, 0, 9743, 9786, 3, 738, 369, 0, 9744, 9786, 3, 740, 370, 0, 9745, + 9786, 3, 742, 371, 0, 9746, 9786, 3, 744, 372, 0, 9747, 9786, 3, 746, 373, + 0, 9748, 9786, 3, 748, 374, 0, 9749, 9786, 3, 752, 376, 0, 9750, 9786, + 3, 754, 377, 0, 9751, 9786, 3, 756, 378, 0, 9752, 9786, 3, 758, 379, 0, + 9753, 9786, 3, 764, 382, 0, 9754, 9786, 3, 766, 383, 0, 9755, 9786, 3, + 768, 384, 0, 9756, 9786, 3, 770, 385, 0, 9757, 9786, 3, 774, 387, 0, 9758, + 9786, 3, 776, 388, 0, 9759, 9786, 3, 778, 389, 0, 9760, 9786, 3, 780, 390, + 0, 9761, 9786, 3, 782, 391, 0, 9762, 9786, 3, 784, 392, 0, 9763, 9786, + 3, 786, 393, 0, 9764, 9786, 3, 788, 394, 0, 9765, 9786, 3, 790, 395, 0, + 9766, 9786, 3, 792, 396, 0, 9767, 9786, 3, 794, 397, 0, 9768, 9786, 3, + 796, 398, 0, 9769, 9786, 3, 798, 399, 0, 9770, 9786, 3, 800, 400, 0, 9771, + 9786, 3, 802, 401, 0, 9772, 9786, 3, 804, 402, 0, 9773, 9786, 3, 806, 403, + 0, 9774, 9786, 3, 808, 404, 0, 9775, 9786, 3, 810, 405, 0, 9776, 9786, + 3, 812, 406, 0, 9777, 9786, 3, 814, 407, 0, 9778, 9786, 3, 816, 408, 0, + 9779, 9786, 3, 818, 409, 0, 9780, 9786, 3, 820, 410, 0, 9781, 9786, 3, + 822, 411, 0, 9782, 9786, 3, 824, 412, 0, 9783, 9786, 3, 826, 413, 0, 9784, + 9786, 3, 828, 414, 0, 9785, 9734, 1, 0, 0, 0, 9785, 9735, 1, 0, 0, 0, 9785, + 9736, 1, 0, 0, 0, 9785, 9737, 1, 0, 0, 0, 9785, 9738, 1, 0, 0, 0, 9785, + 9739, 1, 0, 0, 0, 9785, 9740, 1, 0, 0, 0, 9785, 9741, 1, 0, 0, 0, 9785, + 9742, 1, 0, 0, 0, 9785, 9743, 1, 0, 0, 0, 9785, 9744, 1, 0, 0, 0, 9785, + 9745, 1, 0, 0, 0, 9785, 9746, 1, 0, 0, 0, 9785, 9747, 1, 0, 0, 0, 9785, + 9748, 1, 0, 0, 0, 9785, 9749, 1, 0, 0, 0, 9785, 9750, 1, 0, 0, 0, 9785, + 9751, 1, 0, 0, 0, 9785, 9752, 1, 0, 0, 0, 9785, 9753, 1, 0, 0, 0, 9785, + 9754, 1, 0, 0, 0, 9785, 9755, 1, 0, 0, 0, 9785, 9756, 1, 0, 0, 0, 9785, + 9757, 1, 0, 0, 0, 9785, 9758, 1, 0, 0, 0, 9785, 9759, 1, 0, 0, 0, 9785, + 9760, 1, 0, 0, 0, 9785, 9761, 1, 0, 0, 0, 9785, 9762, 1, 0, 0, 0, 9785, + 9763, 1, 0, 0, 0, 9785, 9764, 1, 0, 0, 0, 9785, 9765, 1, 0, 0, 0, 9785, + 9766, 1, 0, 0, 0, 9785, 9767, 1, 0, 0, 0, 9785, 9768, 1, 0, 0, 0, 9785, + 9769, 1, 0, 0, 0, 9785, 9770, 1, 0, 0, 0, 9785, 9771, 1, 0, 0, 0, 9785, + 9772, 1, 0, 0, 0, 9785, 9773, 1, 0, 0, 0, 9785, 9774, 1, 0, 0, 0, 9785, + 9775, 1, 0, 0, 0, 9785, 9776, 1, 0, 0, 0, 9785, 9777, 1, 0, 0, 0, 9785, + 9778, 1, 0, 0, 0, 9785, 9779, 1, 0, 0, 0, 9785, 9780, 1, 0, 0, 0, 9785, + 9781, 1, 0, 0, 0, 9785, 9782, 1, 0, 0, 0, 9785, 9783, 1, 0, 0, 0, 9785, + 9784, 1, 0, 0, 0, 9786, 715, 1, 0, 0, 0, 9787, 9789, 5, 790, 0, 0, 9788, + 9790, 5, 895, 0, 0, 9789, 9788, 1, 0, 0, 0, 9789, 9790, 1, 0, 0, 0, 9790, + 9791, 1, 0, 0, 0, 9791, 9793, 5, 22, 0, 0, 9792, 9794, 3, 830, 415, 0, + 9793, 9792, 1, 0, 0, 0, 9793, 9794, 1, 0, 0, 0, 9794, 9807, 1, 0, 0, 0, + 9795, 9805, 5, 380, 0, 0, 9796, 9806, 5, 9, 0, 0, 9797, 9799, 5, 207, 0, + 0, 9798, 9800, 3, 856, 428, 0, 9799, 9798, 1, 0, 0, 0, 9799, 9800, 1, 0, + 0, 0, 9800, 9806, 1, 0, 0, 0, 9801, 9803, 5, 757, 0, 0, 9802, 9804, 3, + 834, 417, 0, 9803, 9802, 1, 0, 0, 0, 9803, 9804, 1, 0, 0, 0, 9804, 9806, + 1, 0, 0, 0, 9805, 9796, 1, 0, 0, 0, 9805, 9797, 1, 0, 0, 0, 9805, 9801, + 1, 0, 0, 0, 9806, 9808, 1, 0, 0, 0, 9807, 9795, 1, 0, 0, 0, 9807, 9808, + 1, 0, 0, 0, 9808, 9810, 1, 0, 0, 0, 9809, 9811, 3, 722, 361, 0, 9810, 9809, + 1, 0, 0, 0, 9810, 9811, 1, 0, 0, 0, 9811, 9813, 1, 0, 0, 0, 9812, 9814, + 3, 724, 362, 0, 9813, 9812, 1, 0, 0, 0, 9813, 9814, 1, 0, 0, 0, 9814, 717, + 1, 0, 0, 0, 9815, 9816, 5, 790, 0, 0, 9816, 9818, 5, 158, 0, 0, 9817, 9819, + 3, 830, 415, 0, 9818, 9817, 1, 0, 0, 0, 9818, 9819, 1, 0, 0, 0, 9819, 9842, + 1, 0, 0, 0, 9820, 9840, 5, 380, 0, 0, 9821, 9841, 5, 9, 0, 0, 9822, 9824, + 5, 207, 0, 0, 9823, 9825, 3, 856, 428, 0, 9824, 9823, 1, 0, 0, 0, 9824, + 9825, 1, 0, 0, 0, 9825, 9841, 1, 0, 0, 0, 9826, 9828, 5, 757, 0, 0, 9827, + 9829, 3, 834, 417, 0, 9828, 9827, 1, 0, 0, 0, 9828, 9829, 1, 0, 0, 0, 9829, + 9841, 1, 0, 0, 0, 9830, 9841, 5, 880, 0, 0, 9831, 9833, 5, 880, 0, 0, 9832, + 9831, 1, 0, 0, 0, 9832, 9833, 1, 0, 0, 0, 9833, 9834, 1, 0, 0, 0, 9834, + 9841, 3, 878, 439, 0, 9835, 9841, 5, 1005, 0, 0, 9836, 9838, 5, 1005, 0, + 0, 9837, 9836, 1, 0, 0, 0, 9837, 9838, 1, 0, 0, 0, 9838, 9839, 1, 0, 0, + 0, 9839, 9841, 3, 878, 439, 0, 9840, 9821, 1, 0, 0, 0, 9840, 9822, 1, 0, + 0, 0, 9840, 9826, 1, 0, 0, 0, 9840, 9830, 1, 0, 0, 0, 9840, 9832, 1, 0, + 0, 0, 9840, 9835, 1, 0, 0, 0, 9840, 9837, 1, 0, 0, 0, 9841, 9843, 1, 0, + 0, 0, 9842, 9820, 1, 0, 0, 0, 9842, 9843, 1, 0, 0, 0, 9843, 719, 1, 0, + 0, 0, 9844, 9845, 5, 790, 0, 0, 9845, 9847, 5, 173, 0, 0, 9846, 9848, 3, + 830, 415, 0, 9847, 9846, 1, 0, 0, 0, 9847, 9848, 1, 0, 0, 0, 9848, 721, + 1, 0, 0, 0, 9849, 9850, 5, 830, 0, 0, 9850, 9851, 5, 1020, 0, 0, 9851, + 9852, 3, 852, 426, 0, 9852, 723, 1, 0, 0, 0, 9853, 9854, 5, 431, 0, 0, + 9854, 9857, 3, 880, 440, 0, 9855, 9856, 5, 329, 0, 0, 9856, 9858, 3, 852, + 426, 0, 9857, 9855, 1, 0, 0, 0, 9857, 9858, 1, 0, 0, 0, 9858, 725, 1, 0, + 0, 0, 9859, 9861, 5, 790, 0, 0, 9860, 9862, 5, 895, 0, 0, 9861, 9860, 1, + 0, 0, 0, 9861, 9862, 1, 0, 0, 0, 9862, 9863, 1, 0, 0, 0, 9863, 9865, 5, + 208, 0, 0, 9864, 9866, 5, 361, 0, 0, 9865, 9864, 1, 0, 0, 0, 9865, 9866, + 1, 0, 0, 0, 9866, 9868, 1, 0, 0, 0, 9867, 9869, 3, 830, 415, 0, 9868, 9867, + 1, 0, 0, 0, 9868, 9869, 1, 0, 0, 0, 9869, 9871, 1, 0, 0, 0, 9870, 9872, + 3, 722, 361, 0, 9871, 9870, 1, 0, 0, 0, 9871, 9872, 1, 0, 0, 0, 9872, 9874, + 1, 0, 0, 0, 9873, 9875, 3, 724, 362, 0, 9874, 9873, 1, 0, 0, 0, 9874, 9875, + 1, 0, 0, 0, 9875, 727, 1, 0, 0, 0, 9876, 9877, 5, 790, 0, 0, 9877, 9878, + 5, 208, 0, 0, 9878, 9879, 5, 380, 0, 0, 9879, 9880, 5, 307, 0, 0, 9880, + 9881, 5, 350, 0, 0, 9881, 9882, 3, 856, 428, 0, 9882, 729, 1, 0, 0, 0, + 9883, 9884, 5, 790, 0, 0, 9884, 9885, 5, 208, 0, 0, 9885, 9886, 5, 380, + 0, 0, 9886, 9887, 5, 687, 0, 0, 9887, 9888, 5, 350, 0, 0, 9888, 9889, 3, + 856, 428, 0, 9889, 731, 1, 0, 0, 0, 9890, 9891, 5, 790, 0, 0, 9891, 9892, + 5, 231, 0, 0, 9892, 9907, 5, 61, 0, 0, 9893, 9894, 5, 790, 0, 0, 9894, + 9895, 5, 231, 0, 0, 9895, 9896, 5, 61, 0, 0, 9896, 9897, 5, 110, 0, 0, + 9897, 9898, 5, 984, 0, 0, 9898, 9907, 3, 856, 428, 0, 9899, 9900, 5, 790, + 0, 0, 9900, 9901, 5, 231, 0, 0, 9901, 9902, 5, 61, 0, 0, 9902, 9903, 5, + 922, 0, 0, 9903, 9904, 5, 770, 0, 0, 9904, 9905, 5, 394, 0, 0, 9905, 9907, + 3, 856, 428, 0, 9906, 9890, 1, 0, 0, 0, 9906, 9893, 1, 0, 0, 0, 9906, 9899, + 1, 0, 0, 0, 9907, 733, 1, 0, 0, 0, 9908, 9909, 5, 790, 0, 0, 9909, 9910, + 5, 291, 0, 0, 9910, 9912, 5, 332, 0, 0, 9911, 9913, 3, 830, 415, 0, 9912, + 9911, 1, 0, 0, 0, 9912, 9913, 1, 0, 0, 0, 9913, 735, 1, 0, 0, 0, 9914, + 9915, 5, 790, 0, 0, 9915, 9916, 5, 250, 0, 0, 9916, 9918, 5, 883, 0, 0, + 9917, 9919, 3, 830, 415, 0, 9918, 9917, 1, 0, 0, 0, 9918, 9919, 1, 0, 0, + 0, 9919, 9934, 1, 0, 0, 0, 9920, 9932, 5, 380, 0, 0, 9921, 9933, 5, 9, + 0, 0, 9922, 9924, 5, 207, 0, 0, 9923, 9925, 3, 856, 428, 0, 9924, 9923, + 1, 0, 0, 0, 9924, 9925, 1, 0, 0, 0, 9925, 9933, 1, 0, 0, 0, 9926, 9928, + 5, 757, 0, 0, 9927, 9926, 1, 0, 0, 0, 9927, 9928, 1, 0, 0, 0, 9928, 9930, + 1, 0, 0, 0, 9929, 9931, 3, 834, 417, 0, 9930, 9929, 1, 0, 0, 0, 9930, 9931, + 1, 0, 0, 0, 9931, 9933, 1, 0, 0, 0, 9932, 9921, 1, 0, 0, 0, 9932, 9922, + 1, 0, 0, 0, 9932, 9927, 1, 0, 0, 0, 9933, 9935, 1, 0, 0, 0, 9934, 9920, + 1, 0, 0, 0, 9934, 9935, 1, 0, 0, 0, 9935, 9937, 1, 0, 0, 0, 9936, 9938, + 3, 722, 361, 0, 9937, 9936, 1, 0, 0, 0, 9937, 9938, 1, 0, 0, 0, 9938, 9940, + 1, 0, 0, 0, 9939, 9941, 3, 724, 362, 0, 9940, 9939, 1, 0, 0, 0, 9940, 9941, + 1, 0, 0, 0, 9941, 737, 1, 0, 0, 0, 9942, 9944, 5, 790, 0, 0, 9943, 9945, + 5, 895, 0, 0, 9944, 9943, 1, 0, 0, 0, 9944, 9945, 1, 0, 0, 0, 9945, 9946, + 1, 0, 0, 0, 9946, 9947, 5, 291, 0, 0, 9947, 9949, 5, 883, 0, 0, 9948, 9950, + 3, 830, 415, 0, 9949, 9948, 1, 0, 0, 0, 9949, 9950, 1, 0, 0, 0, 9950, 9965, + 1, 0, 0, 0, 9951, 9963, 5, 380, 0, 0, 9952, 9964, 5, 9, 0, 0, 9953, 9955, + 5, 207, 0, 0, 9954, 9956, 3, 856, 428, 0, 9955, 9954, 1, 0, 0, 0, 9955, + 9956, 1, 0, 0, 0, 9956, 9964, 1, 0, 0, 0, 9957, 9959, 5, 757, 0, 0, 9958, + 9957, 1, 0, 0, 0, 9958, 9959, 1, 0, 0, 0, 9959, 9961, 1, 0, 0, 0, 9960, + 9962, 3, 834, 417, 0, 9961, 9960, 1, 0, 0, 0, 9961, 9962, 1, 0, 0, 0, 9962, + 9964, 1, 0, 0, 0, 9963, 9952, 1, 0, 0, 0, 9963, 9953, 1, 0, 0, 0, 9963, + 9958, 1, 0, 0, 0, 9964, 9966, 1, 0, 0, 0, 9965, 9951, 1, 0, 0, 0, 9965, + 9966, 1, 0, 0, 0, 9966, 9968, 1, 0, 0, 0, 9967, 9969, 3, 722, 361, 0, 9968, + 9967, 1, 0, 0, 0, 9968, 9969, 1, 0, 0, 0, 9969, 9971, 1, 0, 0, 0, 9970, + 9972, 3, 724, 362, 0, 9971, 9970, 1, 0, 0, 0, 9971, 9972, 1, 0, 0, 0, 9972, + 739, 1, 0, 0, 0, 9973, 9974, 5, 790, 0, 0, 9974, 9975, 5, 307, 0, 0, 9975, + 9979, 5, 353, 0, 0, 9976, 9977, 5, 380, 0, 0, 9977, 9978, 5, 9, 0, 0, 9978, + 9980, 3, 856, 428, 0, 9979, 9976, 1, 0, 0, 0, 9979, 9980, 1, 0, 0, 0, 9980, + 741, 1, 0, 0, 0, 9981, 9982, 5, 790, 0, 0, 9982, 9983, 5, 314, 0, 0, 9983, + 9985, 5, 326, 0, 0, 9984, 9986, 3, 830, 415, 0, 9985, 9984, 1, 0, 0, 0, + 9985, 9986, 1, 0, 0, 0, 9986, 9998, 1, 0, 0, 0, 9987, 9996, 5, 380, 0, + 0, 9988, 9997, 5, 9, 0, 0, 9989, 9997, 5, 207, 0, 0, 9990, 9991, 5, 207, + 0, 0, 9991, 9997, 3, 856, 428, 0, 9992, 9997, 5, 757, 0, 0, 9993, 9994, + 5, 757, 0, 0, 9994, 9997, 3, 834, 417, 0, 9995, 9997, 3, 834, 417, 0, 9996, + 9988, 1, 0, 0, 0, 9996, 9989, 1, 0, 0, 0, 9996, 9990, 1, 0, 0, 0, 9996, + 9992, 1, 0, 0, 0, 9996, 9993, 1, 0, 0, 0, 9996, 9995, 1, 0, 0, 0, 9997, + 9999, 1, 0, 0, 0, 9998, 9987, 1, 0, 0, 0, 9998, 9999, 1, 0, 0, 0, 9999, + 743, 1, 0, 0, 0, 10000, 10001, 5, 790, 0, 0, 10001, 10003, 5, 332, 0, 0, + 10002, 10004, 3, 830, 415, 0, 10003, 10002, 1, 0, 0, 0, 10003, 10004, 1, + 0, 0, 0, 10004, 10016, 1, 0, 0, 0, 10005, 10014, 5, 380, 0, 0, 10006, 10015, + 5, 9, 0, 0, 10007, 10015, 5, 207, 0, 0, 10008, 10009, 5, 207, 0, 0, 10009, + 10015, 3, 856, 428, 0, 10010, 10015, 5, 757, 0, 0, 10011, 10012, 5, 757, + 0, 0, 10012, 10015, 3, 856, 428, 0, 10013, 10015, 3, 856, 428, 0, 10014, + 10006, 1, 0, 0, 0, 10014, 10007, 1, 0, 0, 0, 10014, 10008, 1, 0, 0, 0, + 10014, 10010, 1, 0, 0, 0, 10014, 10011, 1, 0, 0, 0, 10014, 10013, 1, 0, + 0, 0, 10015, 10017, 1, 0, 0, 0, 10016, 10005, 1, 0, 0, 0, 10016, 10017, + 1, 0, 0, 0, 10017, 745, 1, 0, 0, 0, 10018, 10019, 5, 790, 0, 0, 10019, + 10020, 5, 345, 0, 0, 10020, 10022, 5, 11, 0, 0, 10021, 10023, 3, 830, 415, + 0, 10022, 10021, 1, 0, 0, 0, 10022, 10023, 1, 0, 0, 0, 10023, 747, 1, 0, + 0, 0, 10024, 10025, 5, 790, 0, 0, 10025, 10027, 5, 349, 0, 0, 10026, 10028, + 3, 750, 375, 0, 10027, 10026, 1, 0, 0, 0, 10027, 10028, 1, 0, 0, 0, 10028, + 10042, 1, 0, 0, 0, 10029, 10030, 5, 790, 0, 0, 10030, 10031, 5, 333, 0, + 0, 10031, 10032, 5, 349, 0, 0, 10032, 10033, 5, 380, 0, 0, 10033, 10034, + 5, 757, 0, 0, 10034, 10042, 3, 834, 417, 0, 10035, 10036, 5, 790, 0, 0, + 10036, 10037, 5, 333, 0, 0, 10037, 10038, 5, 349, 0, 0, 10038, 10039, 5, + 380, 0, 0, 10039, 10040, 5, 207, 0, 0, 10040, 10042, 3, 856, 428, 0, 10041, + 10024, 1, 0, 0, 0, 10041, 10029, 1, 0, 0, 0, 10041, 10035, 1, 0, 0, 0, + 10042, 749, 1, 0, 0, 0, 10043, 10044, 5, 553, 0, 0, 10044, 10065, 5, 9, + 0, 0, 10045, 10046, 5, 553, 0, 0, 10046, 10047, 3, 836, 418, 0, 10047, + 10048, 3, 878, 439, 0, 10048, 10065, 1, 0, 0, 0, 10049, 10056, 5, 922, + 0, 0, 10050, 10051, 5, 718, 0, 0, 10051, 10057, 3, 856, 428, 0, 10052, + 10053, 5, 984, 0, 0, 10053, 10057, 3, 856, 428, 0, 10054, 10055, 5, 786, + 0, 0, 10055, 10057, 3, 856, 428, 0, 10056, 10050, 1, 0, 0, 0, 10056, 10052, + 1, 0, 0, 0, 10056, 10054, 1, 0, 0, 0, 10057, 10065, 1, 0, 0, 0, 10058, + 10059, 5, 542, 0, 0, 10059, 10060, 5, 718, 0, 0, 10060, 10065, 3, 856, + 428, 0, 10061, 10062, 5, 542, 0, 0, 10062, 10063, 5, 786, 0, 0, 10063, + 10065, 3, 856, 428, 0, 10064, 10043, 1, 0, 0, 0, 10064, 10045, 1, 0, 0, + 0, 10064, 10049, 1, 0, 0, 0, 10064, 10058, 1, 0, 0, 0, 10064, 10061, 1, + 0, 0, 0, 10065, 751, 1, 0, 0, 0, 10066, 10068, 5, 790, 0, 0, 10067, 10069, + 7, 56, 0, 0, 10068, 10067, 1, 0, 0, 0, 10068, 10069, 1, 0, 0, 0, 10069, + 10070, 1, 0, 0, 0, 10070, 10072, 5, 395, 0, 0, 10071, 10073, 3, 830, 415, + 0, 10072, 10071, 1, 0, 0, 0, 10072, 10073, 1, 0, 0, 0, 10073, 753, 1, 0, + 0, 0, 10074, 10075, 5, 790, 0, 0, 10075, 10078, 5, 441, 0, 0, 10076, 10077, + 5, 380, 0, 0, 10077, 10079, 5, 9, 0, 0, 10078, 10076, 1, 0, 0, 0, 10078, + 10079, 1, 0, 0, 0, 10079, 755, 1, 0, 0, 0, 10080, 10081, 5, 790, 0, 0, + 10081, 10082, 5, 452, 0, 0, 10082, 10084, 5, 11, 0, 0, 10083, 10085, 3, + 830, 415, 0, 10084, 10083, 1, 0, 0, 0, 10084, 10085, 1, 0, 0, 0, 10085, + 757, 1, 0, 0, 0, 10086, 10087, 5, 790, 0, 0, 10087, 10088, 5, 455, 0, 0, + 10088, 10090, 5, 607, 0, 0, 10089, 10091, 3, 830, 415, 0, 10090, 10089, + 1, 0, 0, 0, 10090, 10091, 1, 0, 0, 0, 10091, 10093, 1, 0, 0, 0, 10092, + 10094, 3, 760, 380, 0, 10093, 10092, 1, 0, 0, 0, 10093, 10094, 1, 0, 0, + 0, 10094, 759, 1, 0, 0, 0, 10095, 10104, 5, 380, 0, 0, 10096, 10105, 5, + 9, 0, 0, 10097, 10105, 5, 207, 0, 0, 10098, 10099, 5, 207, 0, 0, 10099, + 10105, 3, 856, 428, 0, 10100, 10105, 5, 757, 0, 0, 10101, 10102, 5, 757, + 0, 0, 10102, 10105, 3, 834, 417, 0, 10103, 10105, 3, 834, 417, 0, 10104, + 10096, 1, 0, 0, 0, 10104, 10097, 1, 0, 0, 0, 10104, 10098, 1, 0, 0, 0, + 10104, 10100, 1, 0, 0, 0, 10104, 10101, 1, 0, 0, 0, 10104, 10103, 1, 0, + 0, 0, 10105, 761, 1, 0, 0, 0, 10106, 10119, 5, 380, 0, 0, 10107, 10120, + 5, 9, 0, 0, 10108, 10110, 5, 207, 0, 0, 10109, 10111, 3, 856, 428, 0, 10110, + 10109, 1, 0, 0, 0, 10110, 10111, 1, 0, 0, 0, 10111, 10120, 1, 0, 0, 0, + 10112, 10114, 5, 757, 0, 0, 10113, 10115, 3, 834, 417, 0, 10114, 10113, + 1, 0, 0, 0, 10114, 10115, 1, 0, 0, 0, 10115, 10120, 1, 0, 0, 0, 10116, + 10120, 5, 880, 0, 0, 10117, 10118, 5, 880, 0, 0, 10118, 10120, 3, 878, + 439, 0, 10119, 10107, 1, 0, 0, 0, 10119, 10108, 1, 0, 0, 0, 10119, 10112, + 1, 0, 0, 0, 10119, 10116, 1, 0, 0, 0, 10119, 10117, 1, 0, 0, 0, 10120, + 763, 1, 0, 0, 0, 10121, 10122, 5, 790, 0, 0, 10122, 10123, 5, 463, 0, 0, + 10123, 10125, 5, 1006, 0, 0, 10124, 10126, 3, 830, 415, 0, 10125, 10124, + 1, 0, 0, 0, 10125, 10126, 1, 0, 0, 0, 10126, 10128, 1, 0, 0, 0, 10127, + 10129, 3, 760, 380, 0, 10128, 10127, 1, 0, 0, 0, 10128, 10129, 1, 0, 0, + 0, 10129, 765, 1, 0, 0, 0, 10130, 10131, 5, 790, 0, 0, 10131, 10132, 5, + 496, 0, 0, 10132, 10133, 5, 607, 0, 0, 10133, 767, 1, 0, 0, 0, 10134, 10135, + 5, 790, 0, 0, 10135, 10137, 5, 540, 0, 0, 10136, 10138, 3, 830, 415, 0, + 10137, 10136, 1, 0, 0, 0, 10137, 10138, 1, 0, 0, 0, 10138, 10140, 1, 0, + 0, 0, 10139, 10141, 3, 760, 380, 0, 10140, 10139, 1, 0, 0, 0, 10140, 10141, + 1, 0, 0, 0, 10141, 769, 1, 0, 0, 0, 10142, 10143, 5, 790, 0, 0, 10143, + 10144, 5, 569, 0, 0, 10144, 10146, 5, 11, 0, 0, 10145, 10147, 3, 830, 415, + 0, 10146, 10145, 1, 0, 0, 0, 10146, 10147, 1, 0, 0, 0, 10147, 771, 1, 0, + 0, 0, 10148, 10149, 7, 61, 0, 0, 10149, 773, 1, 0, 0, 0, 10150, 10151, + 5, 790, 0, 0, 10151, 10153, 5, 579, 0, 0, 10152, 10154, 3, 830, 415, 0, + 10153, 10152, 1, 0, 0, 0, 10153, 10154, 1, 0, 0, 0, 10154, 10170, 1, 0, + 0, 0, 10155, 10168, 3, 772, 386, 0, 10156, 10169, 5, 779, 0, 0, 10157, + 10169, 5, 9, 0, 0, 10158, 10160, 5, 984, 0, 0, 10159, 10161, 3, 856, 428, + 0, 10160, 10159, 1, 0, 0, 0, 10160, 10161, 1, 0, 0, 0, 10161, 10169, 1, + 0, 0, 0, 10162, 10164, 7, 62, 0, 0, 10163, 10165, 3, 856, 428, 0, 10164, + 10163, 1, 0, 0, 0, 10164, 10165, 1, 0, 0, 0, 10165, 10169, 1, 0, 0, 0, + 10166, 10167, 5, 880, 0, 0, 10167, 10169, 3, 878, 439, 0, 10168, 10156, + 1, 0, 0, 0, 10168, 10157, 1, 0, 0, 0, 10168, 10158, 1, 0, 0, 0, 10168, + 10162, 1, 0, 0, 0, 10168, 10166, 1, 0, 0, 0, 10169, 10171, 1, 0, 0, 0, + 10170, 10155, 1, 0, 0, 0, 10170, 10171, 1, 0, 0, 0, 10171, 775, 1, 0, 0, + 0, 10172, 10173, 5, 790, 0, 0, 10173, 10175, 5, 602, 0, 0, 10174, 10176, + 3, 830, 415, 0, 10175, 10174, 1, 0, 0, 0, 10175, 10176, 1, 0, 0, 0, 10176, + 10178, 1, 0, 0, 0, 10177, 10179, 3, 760, 380, 0, 10178, 10177, 1, 0, 0, + 0, 10178, 10179, 1, 0, 0, 0, 10179, 777, 1, 0, 0, 0, 10180, 10182, 5, 790, + 0, 0, 10181, 10183, 5, 895, 0, 0, 10182, 10181, 1, 0, 0, 0, 10182, 10183, + 1, 0, 0, 0, 10183, 10184, 1, 0, 0, 0, 10184, 10185, 5, 619, 0, 0, 10185, + 10187, 5, 414, 0, 0, 10186, 10188, 3, 762, 381, 0, 10187, 10186, 1, 0, + 0, 0, 10187, 10188, 1, 0, 0, 0, 10188, 779, 1, 0, 0, 0, 10189, 10190, 5, + 790, 0, 0, 10190, 10192, 5, 629, 0, 0, 10191, 10193, 3, 830, 415, 0, 10192, + 10191, 1, 0, 0, 0, 10192, 10193, 1, 0, 0, 0, 10193, 10195, 1, 0, 0, 0, + 10194, 10196, 3, 760, 380, 0, 10195, 10194, 1, 0, 0, 0, 10195, 10196, 1, + 0, 0, 0, 10196, 781, 1, 0, 0, 0, 10197, 10198, 5, 790, 0, 0, 10198, 10200, + 5, 674, 0, 0, 10199, 10201, 3, 830, 415, 0, 10200, 10199, 1, 0, 0, 0, 10200, + 10201, 1, 0, 0, 0, 10201, 783, 1, 0, 0, 0, 10202, 10203, 5, 790, 0, 0, + 10203, 10204, 5, 687, 0, 0, 10204, 10206, 5, 11, 0, 0, 10205, 10207, 3, + 830, 415, 0, 10206, 10205, 1, 0, 0, 0, 10206, 10207, 1, 0, 0, 0, 10207, + 785, 1, 0, 0, 0, 10208, 10209, 5, 790, 0, 0, 10209, 10210, 5, 687, 0, 0, + 10210, 10212, 5, 208, 0, 0, 10211, 10213, 3, 830, 415, 0, 10212, 10211, + 1, 0, 0, 0, 10212, 10213, 1, 0, 0, 0, 10213, 10220, 1, 0, 0, 0, 10214, + 10215, 5, 1020, 0, 0, 10215, 10216, 5, 619, 0, 0, 10216, 10217, 3, 832, + 416, 0, 10217, 10218, 5, 1099, 0, 0, 10218, 10219, 3, 856, 428, 0, 10219, + 10221, 1, 0, 0, 0, 10220, 10214, 1, 0, 0, 0, 10220, 10221, 1, 0, 0, 0, + 10221, 787, 1, 0, 0, 0, 10222, 10223, 5, 790, 0, 0, 10223, 10224, 5, 687, + 0, 0, 10224, 10228, 5, 353, 0, 0, 10225, 10226, 5, 380, 0, 0, 10226, 10227, + 5, 9, 0, 0, 10227, 10229, 3, 856, 428, 0, 10228, 10225, 1, 0, 0, 0, 10228, + 10229, 1, 0, 0, 0, 10229, 789, 1, 0, 0, 0, 10230, 10231, 5, 790, 0, 0, + 10231, 10232, 5, 694, 0, 0, 10232, 10234, 5, 485, 0, 0, 10233, 10235, 3, + 830, 415, 0, 10234, 10233, 1, 0, 0, 0, 10234, 10235, 1, 0, 0, 0, 10235, + 791, 1, 0, 0, 0, 10236, 10237, 5, 790, 0, 0, 10237, 10239, 5, 719, 0, 0, + 10238, 10240, 3, 830, 415, 0, 10239, 10238, 1, 0, 0, 0, 10239, 10240, 1, + 0, 0, 0, 10240, 793, 1, 0, 0, 0, 10241, 10242, 5, 790, 0, 0, 10242, 10243, + 5, 723, 0, 0, 10243, 10244, 5, 8, 0, 0, 10244, 10246, 5, 607, 0, 0, 10245, + 10247, 3, 830, 415, 0, 10246, 10245, 1, 0, 0, 0, 10246, 10247, 1, 0, 0, + 0, 10247, 10249, 1, 0, 0, 0, 10248, 10250, 3, 760, 380, 0, 10249, 10248, + 1, 0, 0, 0, 10249, 10250, 1, 0, 0, 0, 10250, 795, 1, 0, 0, 0, 10251, 10253, + 5, 790, 0, 0, 10252, 10254, 5, 895, 0, 0, 10253, 10252, 1, 0, 0, 0, 10253, + 10254, 1, 0, 0, 0, 10254, 10255, 1, 0, 0, 0, 10255, 10257, 5, 758, 0, 0, + 10256, 10258, 5, 361, 0, 0, 10257, 10256, 1, 0, 0, 0, 10257, 10258, 1, + 0, 0, 0, 10258, 10260, 1, 0, 0, 0, 10259, 10261, 3, 830, 415, 0, 10260, + 10259, 1, 0, 0, 0, 10260, 10261, 1, 0, 0, 0, 10261, 10270, 1, 0, 0, 0, + 10262, 10268, 5, 380, 0, 0, 10263, 10269, 5, 9, 0, 0, 10264, 10266, 5, + 207, 0, 0, 10265, 10267, 3, 856, 428, 0, 10266, 10265, 1, 0, 0, 0, 10266, + 10267, 1, 0, 0, 0, 10267, 10269, 1, 0, 0, 0, 10268, 10263, 1, 0, 0, 0, + 10268, 10264, 1, 0, 0, 0, 10269, 10271, 1, 0, 0, 0, 10270, 10262, 1, 0, + 0, 0, 10270, 10271, 1, 0, 0, 0, 10271, 10273, 1, 0, 0, 0, 10272, 10274, + 3, 722, 361, 0, 10273, 10272, 1, 0, 0, 0, 10273, 10274, 1, 0, 0, 0, 10274, + 10276, 1, 0, 0, 0, 10275, 10277, 3, 724, 362, 0, 10276, 10275, 1, 0, 0, + 0, 10276, 10277, 1, 0, 0, 0, 10277, 797, 1, 0, 0, 0, 10278, 10279, 5, 790, + 0, 0, 10279, 10281, 5, 776, 0, 0, 10280, 10282, 3, 830, 415, 0, 10281, + 10280, 1, 0, 0, 0, 10281, 10282, 1, 0, 0, 0, 10282, 10284, 1, 0, 0, 0, + 10283, 10285, 3, 760, 380, 0, 10284, 10283, 1, 0, 0, 0, 10284, 10285, 1, + 0, 0, 0, 10285, 799, 1, 0, 0, 0, 10286, 10287, 5, 790, 0, 0, 10287, 10288, + 5, 779, 0, 0, 10288, 10289, 5, 607, 0, 0, 10289, 801, 1, 0, 0, 0, 10290, + 10291, 5, 790, 0, 0, 10291, 10293, 5, 788, 0, 0, 10292, 10294, 3, 830, + 415, 0, 10293, 10292, 1, 0, 0, 0, 10293, 10294, 1, 0, 0, 0, 10294, 803, + 1, 0, 0, 0, 10295, 10296, 5, 790, 0, 0, 10296, 10297, 5, 788, 0, 0, 10297, + 10298, 5, 380, 0, 0, 10298, 10299, 5, 307, 0, 0, 10299, 10300, 5, 350, + 0, 0, 10300, 10301, 3, 856, 428, 0, 10301, 805, 1, 0, 0, 0, 10302, 10303, + 5, 790, 0, 0, 10303, 10304, 5, 788, 0, 0, 10304, 10305, 5, 380, 0, 0, 10305, + 10306, 5, 687, 0, 0, 10306, 10307, 5, 350, 0, 0, 10307, 10308, 3, 856, + 428, 0, 10308, 807, 1, 0, 0, 0, 10309, 10310, 5, 790, 0, 0, 10310, 10312, + 5, 823, 0, 0, 10311, 10313, 3, 830, 415, 0, 10312, 10311, 1, 0, 0, 0, 10312, + 10313, 1, 0, 0, 0, 10313, 10315, 1, 0, 0, 0, 10314, 10316, 3, 760, 380, + 0, 10315, 10314, 1, 0, 0, 0, 10315, 10316, 1, 0, 0, 0, 10316, 809, 1, 0, + 0, 0, 10317, 10318, 5, 790, 0, 0, 10318, 10320, 5, 858, 0, 0, 10319, 10321, + 3, 830, 415, 0, 10320, 10319, 1, 0, 0, 0, 10320, 10321, 1, 0, 0, 0, 10321, + 10323, 1, 0, 0, 0, 10322, 10324, 3, 760, 380, 0, 10323, 10322, 1, 0, 0, + 0, 10323, 10324, 1, 0, 0, 0, 10324, 811, 1, 0, 0, 0, 10325, 10326, 5, 790, + 0, 0, 10326, 10328, 5, 883, 0, 0, 10327, 10329, 3, 830, 415, 0, 10328, + 10327, 1, 0, 0, 0, 10328, 10329, 1, 0, 0, 0, 10329, 10331, 1, 0, 0, 0, + 10330, 10332, 3, 760, 380, 0, 10331, 10330, 1, 0, 0, 0, 10331, 10332, 1, + 0, 0, 0, 10332, 813, 1, 0, 0, 0, 10333, 10334, 5, 790, 0, 0, 10334, 10336, + 5, 888, 0, 0, 10335, 10337, 3, 830, 415, 0, 10336, 10335, 1, 0, 0, 0, 10336, + 10337, 1, 0, 0, 0, 10337, 10347, 1, 0, 0, 0, 10338, 10339, 5, 380, 0, 0, + 10339, 10348, 5, 9, 0, 0, 10340, 10348, 5, 207, 0, 0, 10341, 10342, 5, + 207, 0, 0, 10342, 10348, 3, 856, 428, 0, 10343, 10348, 5, 757, 0, 0, 10344, + 10345, 5, 757, 0, 0, 10345, 10348, 3, 834, 417, 0, 10346, 10348, 3, 834, + 417, 0, 10347, 10338, 1, 0, 0, 0, 10347, 10340, 1, 0, 0, 0, 10347, 10341, + 1, 0, 0, 0, 10347, 10343, 1, 0, 0, 0, 10347, 10344, 1, 0, 0, 0, 10347, + 10346, 1, 0, 0, 0, 10347, 10348, 1, 0, 0, 0, 10348, 815, 1, 0, 0, 0, 10349, + 10351, 5, 790, 0, 0, 10350, 10352, 5, 895, 0, 0, 10351, 10350, 1, 0, 0, + 0, 10351, 10352, 1, 0, 0, 0, 10352, 10353, 1, 0, 0, 0, 10353, 10355, 5, + 892, 0, 0, 10354, 10356, 3, 830, 415, 0, 10355, 10354, 1, 0, 0, 0, 10355, + 10356, 1, 0, 0, 0, 10356, 10371, 1, 0, 0, 0, 10357, 10369, 5, 380, 0, 0, + 10358, 10370, 5, 9, 0, 0, 10359, 10361, 5, 207, 0, 0, 10360, 10362, 3, + 856, 428, 0, 10361, 10360, 1, 0, 0, 0, 10361, 10362, 1, 0, 0, 0, 10362, + 10370, 1, 0, 0, 0, 10363, 10365, 5, 757, 0, 0, 10364, 10363, 1, 0, 0, 0, + 10364, 10365, 1, 0, 0, 0, 10365, 10367, 1, 0, 0, 0, 10366, 10368, 3, 834, + 417, 0, 10367, 10366, 1, 0, 0, 0, 10367, 10368, 1, 0, 0, 0, 10368, 10370, + 1, 0, 0, 0, 10369, 10358, 1, 0, 0, 0, 10369, 10359, 1, 0, 0, 0, 10369, + 10364, 1, 0, 0, 0, 10370, 10372, 1, 0, 0, 0, 10371, 10357, 1, 0, 0, 0, + 10371, 10372, 1, 0, 0, 0, 10372, 10374, 1, 0, 0, 0, 10373, 10375, 3, 722, + 361, 0, 10374, 10373, 1, 0, 0, 0, 10374, 10375, 1, 0, 0, 0, 10375, 10377, + 1, 0, 0, 0, 10376, 10378, 3, 724, 362, 0, 10377, 10376, 1, 0, 0, 0, 10377, + 10378, 1, 0, 0, 0, 10378, 817, 1, 0, 0, 0, 10379, 10380, 5, 790, 0, 0, + 10380, 10383, 5, 931, 0, 0, 10381, 10382, 5, 380, 0, 0, 10382, 10384, 5, + 9, 0, 0, 10383, 10381, 1, 0, 0, 0, 10383, 10384, 1, 0, 0, 0, 10384, 819, + 1, 0, 0, 0, 10385, 10386, 5, 790, 0, 0, 10386, 10387, 5, 984, 0, 0, 10387, + 10389, 5, 332, 0, 0, 10388, 10390, 3, 830, 415, 0, 10389, 10388, 1, 0, + 0, 0, 10389, 10390, 1, 0, 0, 0, 10390, 10392, 1, 0, 0, 0, 10391, 10393, + 3, 760, 380, 0, 10392, 10391, 1, 0, 0, 0, 10392, 10393, 1, 0, 0, 0, 10393, + 821, 1, 0, 0, 0, 10394, 10396, 5, 790, 0, 0, 10395, 10397, 5, 895, 0, 0, + 10396, 10395, 1, 0, 0, 0, 10396, 10397, 1, 0, 0, 0, 10397, 10398, 1, 0, + 0, 0, 10398, 10400, 5, 986, 0, 0, 10399, 10401, 3, 830, 415, 0, 10400, + 10399, 1, 0, 0, 0, 10400, 10401, 1, 0, 0, 0, 10401, 10405, 1, 0, 0, 0, + 10402, 10403, 5, 830, 0, 0, 10403, 10404, 5, 1020, 0, 0, 10404, 10406, + 3, 852, 426, 0, 10405, 10402, 1, 0, 0, 0, 10405, 10406, 1, 0, 0, 0, 10406, + 10409, 1, 0, 0, 0, 10407, 10408, 5, 431, 0, 0, 10408, 10410, 3, 880, 440, + 0, 10409, 10407, 1, 0, 0, 0, 10409, 10410, 1, 0, 0, 0, 10410, 10413, 1, + 0, 0, 0, 10411, 10412, 5, 329, 0, 0, 10412, 10414, 3, 852, 426, 0, 10413, + 10411, 1, 0, 0, 0, 10413, 10414, 1, 0, 0, 0, 10414, 823, 1, 0, 0, 0, 10415, + 10416, 5, 790, 0, 0, 10416, 10418, 5, 1001, 0, 0, 10417, 10419, 3, 830, + 415, 0, 10418, 10417, 1, 0, 0, 0, 10418, 10419, 1, 0, 0, 0, 10419, 825, + 1, 0, 0, 0, 10420, 10422, 5, 790, 0, 0, 10421, 10423, 5, 895, 0, 0, 10422, + 10421, 1, 0, 0, 0, 10422, 10423, 1, 0, 0, 0, 10423, 10424, 1, 0, 0, 0, + 10424, 10426, 5, 1006, 0, 0, 10425, 10427, 3, 830, 415, 0, 10426, 10425, + 1, 0, 0, 0, 10426, 10427, 1, 0, 0, 0, 10427, 10442, 1, 0, 0, 0, 10428, + 10440, 5, 380, 0, 0, 10429, 10441, 5, 9, 0, 0, 10430, 10432, 5, 207, 0, + 0, 10431, 10433, 3, 856, 428, 0, 10432, 10431, 1, 0, 0, 0, 10432, 10433, + 1, 0, 0, 0, 10433, 10441, 1, 0, 0, 0, 10434, 10436, 5, 757, 0, 0, 10435, + 10434, 1, 0, 0, 0, 10435, 10436, 1, 0, 0, 0, 10436, 10438, 1, 0, 0, 0, + 10437, 10439, 3, 834, 417, 0, 10438, 10437, 1, 0, 0, 0, 10438, 10439, 1, + 0, 0, 0, 10439, 10441, 1, 0, 0, 0, 10440, 10429, 1, 0, 0, 0, 10440, 10430, + 1, 0, 0, 0, 10440, 10435, 1, 0, 0, 0, 10441, 10443, 1, 0, 0, 0, 10442, + 10428, 1, 0, 0, 0, 10442, 10443, 1, 0, 0, 0, 10443, 10445, 1, 0, 0, 0, + 10444, 10446, 3, 722, 361, 0, 10445, 10444, 1, 0, 0, 0, 10445, 10446, 1, + 0, 0, 0, 10446, 10448, 1, 0, 0, 0, 10447, 10449, 3, 724, 362, 0, 10448, + 10447, 1, 0, 0, 0, 10448, 10449, 1, 0, 0, 0, 10449, 827, 1, 0, 0, 0, 10450, + 10451, 5, 790, 0, 0, 10451, 10453, 5, 1012, 0, 0, 10452, 10454, 3, 830, + 415, 0, 10453, 10452, 1, 0, 0, 0, 10453, 10454, 1, 0, 0, 0, 10454, 829, + 1, 0, 0, 0, 10455, 10456, 5, 430, 0, 0, 10456, 10457, 3, 852, 426, 0, 10457, + 831, 1, 0, 0, 0, 10458, 10459, 3, 856, 428, 0, 10459, 833, 1, 0, 0, 0, + 10460, 10461, 3, 856, 428, 0, 10461, 10462, 5, 1099, 0, 0, 10462, 10463, + 3, 856, 428, 0, 10463, 10466, 1, 0, 0, 0, 10464, 10466, 3, 856, 428, 0, + 10465, 10460, 1, 0, 0, 0, 10465, 10464, 1, 0, 0, 0, 10466, 835, 1, 0, 0, + 0, 10467, 10468, 5, 9, 0, 0, 10468, 10480, 5, 579, 0, 0, 10469, 10480, + 5, 208, 0, 0, 10470, 10480, 5, 395, 0, 0, 10471, 10472, 5, 496, 0, 0, 10472, + 10480, 5, 607, 0, 0, 10473, 10474, 5, 694, 0, 0, 10474, 10480, 5, 485, + 0, 0, 10475, 10480, 5, 719, 0, 0, 10476, 10480, 5, 788, 0, 0, 10477, 10480, + 5, 986, 0, 0, 10478, 10480, 5, 1012, 0, 0, 10479, 10467, 1, 0, 0, 0, 10479, + 10469, 1, 0, 0, 0, 10479, 10470, 1, 0, 0, 0, 10479, 10471, 1, 0, 0, 0, + 10479, 10473, 1, 0, 0, 0, 10479, 10475, 1, 0, 0, 0, 10479, 10476, 1, 0, + 0, 0, 10479, 10477, 1, 0, 0, 0, 10479, 10478, 1, 0, 0, 0, 10480, 837, 1, + 0, 0, 0, 10481, 10486, 3, 836, 418, 0, 10482, 10483, 5, 1110, 0, 0, 10483, + 10485, 3, 836, 418, 0, 10484, 10482, 1, 0, 0, 0, 10485, 10488, 1, 0, 0, + 0, 10486, 10484, 1, 0, 0, 0, 10486, 10487, 1, 0, 0, 0, 10487, 839, 1, 0, + 0, 0, 10488, 10486, 1, 0, 0, 0, 10489, 10490, 3, 852, 426, 0, 10490, 841, + 1, 0, 0, 0, 10491, 10492, 3, 856, 428, 0, 10492, 843, 1, 0, 0, 0, 10493, + 10494, 3, 856, 428, 0, 10494, 845, 1, 0, 0, 0, 10495, 10496, 3, 856, 428, + 0, 10496, 847, 1, 0, 0, 0, 10497, 10498, 3, 856, 428, 0, 10498, 849, 1, + 0, 0, 0, 10499, 10500, 3, 856, 428, 0, 10500, 851, 1, 0, 0, 0, 10501, 10502, + 5, 1083, 0, 0, 10502, 853, 1, 0, 0, 0, 10503, 10508, 3, 852, 426, 0, 10504, + 10505, 5, 1110, 0, 0, 10505, 10507, 3, 852, 426, 0, 10506, 10504, 1, 0, + 0, 0, 10507, 10510, 1, 0, 0, 0, 10508, 10506, 1, 0, 0, 0, 10508, 10509, + 1, 0, 0, 0, 10509, 855, 1, 0, 0, 0, 10510, 10508, 1, 0, 0, 0, 10511, 10524, + 5, 1076, 0, 0, 10512, 10524, 5, 1077, 0, 0, 10513, 10524, 5, 1073, 0, 0, + 10514, 10524, 5, 1074, 0, 0, 10515, 10524, 3, 858, 429, 0, 10516, 10524, + 3, 860, 430, 0, 10517, 10524, 3, 902, 451, 0, 10518, 10524, 3, 862, 431, + 0, 10519, 10524, 5, 21, 0, 0, 10520, 10524, 5, 22, 0, 0, 10521, 10524, + 5, 169, 0, 0, 10522, 10524, 3, 1080, 540, 0, 10523, 10511, 1, 0, 0, 0, + 10523, 10512, 1, 0, 0, 0, 10523, 10513, 1, 0, 0, 0, 10523, 10514, 1, 0, + 0, 0, 10523, 10515, 1, 0, 0, 0, 10523, 10516, 1, 0, 0, 0, 10523, 10517, + 1, 0, 0, 0, 10523, 10518, 1, 0, 0, 0, 10523, 10519, 1, 0, 0, 0, 10523, + 10520, 1, 0, 0, 0, 10523, 10521, 1, 0, 0, 0, 10523, 10522, 1, 0, 0, 0, + 10524, 857, 1, 0, 0, 0, 10525, 10526, 7, 63, 0, 0, 10526, 859, 1, 0, 0, + 0, 10527, 10528, 7, 64, 0, 0, 10528, 861, 1, 0, 0, 0, 10529, 10530, 7, + 65, 0, 0, 10530, 863, 1, 0, 0, 0, 10531, 10532, 7, 66, 0, 0, 10532, 865, + 1, 0, 0, 0, 10533, 10541, 7, 67, 0, 0, 10534, 10541, 5, 343, 0, 0, 10535, + 10541, 5, 426, 0, 0, 10536, 10541, 5, 716, 0, 0, 10537, 10541, 5, 217, + 0, 0, 10538, 10541, 7, 68, 0, 0, 10539, 10541, 5, 818, 0, 0, 10540, 10533, + 1, 0, 0, 0, 10540, 10534, 1, 0, 0, 0, 10540, 10535, 1, 0, 0, 0, 10540, + 10536, 1, 0, 0, 0, 10540, 10537, 1, 0, 0, 0, 10540, 10538, 1, 0, 0, 0, + 10540, 10539, 1, 0, 0, 0, 10541, 867, 1, 0, 0, 0, 10542, 10548, 5, 130, + 0, 0, 10543, 10548, 5, 684, 0, 0, 10544, 10548, 7, 69, 0, 0, 10545, 10548, + 5, 430, 0, 0, 10546, 10548, 5, 373, 0, 0, 10547, 10542, 1, 0, 0, 0, 10547, + 10543, 1, 0, 0, 0, 10547, 10544, 1, 0, 0, 0, 10547, 10545, 1, 0, 0, 0, + 10547, 10546, 1, 0, 0, 0, 10548, 869, 1, 0, 0, 0, 10549, 10553, 7, 70, + 0, 0, 10550, 10553, 7, 71, 0, 0, 10551, 10553, 5, 819, 0, 0, 10552, 10549, + 1, 0, 0, 0, 10552, 10550, 1, 0, 0, 0, 10552, 10551, 1, 0, 0, 0, 10553, + 871, 1, 0, 0, 0, 10554, 10555, 5, 590, 0, 0, 10555, 10556, 5, 1092, 0, + 0, 10556, 10557, 3, 852, 426, 0, 10557, 873, 1, 0, 0, 0, 10558, 10559, + 3, 856, 428, 0, 10559, 875, 1, 0, 0, 0, 10560, 10565, 3, 874, 437, 0, 10561, + 10562, 5, 1110, 0, 0, 10562, 10564, 3, 874, 437, 0, 10563, 10561, 1, 0, + 0, 0, 10564, 10567, 1, 0, 0, 0, 10565, 10563, 1, 0, 0, 0, 10565, 10566, + 1, 0, 0, 0, 10566, 877, 1, 0, 0, 0, 10567, 10565, 1, 0, 0, 0, 10568, 10569, + 3, 856, 428, 0, 10569, 10570, 5, 1099, 0, 0, 10570, 10571, 3, 856, 428, + 0, 10571, 10572, 5, 1099, 0, 0, 10572, 10573, 3, 856, 428, 0, 10573, 10580, + 1, 0, 0, 0, 10574, 10575, 3, 856, 428, 0, 10575, 10576, 5, 1099, 0, 0, + 10576, 10577, 3, 856, 428, 0, 10577, 10580, 1, 0, 0, 0, 10578, 10580, 3, + 856, 428, 0, 10579, 10568, 1, 0, 0, 0, 10579, 10574, 1, 0, 0, 0, 10579, + 10578, 1, 0, 0, 0, 10580, 879, 1, 0, 0, 0, 10581, 10582, 5, 1084, 0, 0, + 10582, 881, 1, 0, 0, 0, 10583, 10588, 3, 886, 443, 0, 10584, 10585, 5, + 1110, 0, 0, 10585, 10587, 3, 886, 443, 0, 10586, 10584, 1, 0, 0, 0, 10587, + 10590, 1, 0, 0, 0, 10588, 10586, 1, 0, 0, 0, 10588, 10589, 1, 0, 0, 0, + 10589, 883, 1, 0, 0, 0, 10590, 10588, 1, 0, 0, 0, 10591, 10593, 3, 886, + 443, 0, 10592, 10594, 3, 908, 454, 0, 10593, 10592, 1, 0, 0, 0, 10593, + 10594, 1, 0, 0, 0, 10594, 10602, 1, 0, 0, 0, 10595, 10596, 5, 1110, 0, + 0, 10596, 10598, 3, 886, 443, 0, 10597, 10599, 3, 908, 454, 0, 10598, 10597, + 1, 0, 0, 0, 10598, 10599, 1, 0, 0, 0, 10599, 10601, 1, 0, 0, 0, 10600, + 10595, 1, 0, 0, 0, 10601, 10604, 1, 0, 0, 0, 10602, 10600, 1, 0, 0, 0, + 10602, 10603, 1, 0, 0, 0, 10603, 885, 1, 0, 0, 0, 10604, 10602, 1, 0, 0, + 0, 10605, 10606, 6, 443, -1, 0, 10606, 10663, 3, 904, 452, 0, 10607, 10663, + 3, 912, 456, 0, 10608, 10663, 3, 926, 463, 0, 10609, 10663, 3, 888, 444, + 0, 10610, 10663, 3, 922, 461, 0, 10611, 10663, 3, 924, 462, 0, 10612, 10613, + 7, 72, 0, 0, 10613, 10663, 3, 886, 443, 26, 10614, 10615, 5, 511, 0, 0, + 10615, 10663, 3, 886, 443, 25, 10616, 10663, 3, 900, 450, 0, 10617, 10618, + 5, 120, 0, 0, 10618, 10619, 5, 1104, 0, 0, 10619, 10620, 3, 886, 443, 0, + 10620, 10621, 5, 56, 0, 0, 10621, 10622, 3, 902, 451, 0, 10622, 10623, + 5, 1105, 0, 0, 10623, 10663, 1, 0, 0, 0, 10624, 10663, 3, 894, 447, 0, + 10625, 10626, 3, 866, 433, 0, 10626, 10627, 5, 1104, 0, 0, 10627, 10628, + 3, 886, 443, 0, 10628, 10629, 5, 1110, 0, 0, 10629, 10630, 3, 886, 443, + 0, 10630, 10631, 5, 1105, 0, 0, 10631, 10663, 1, 0, 0, 0, 10632, 10633, + 3, 868, 434, 0, 10633, 10634, 5, 1104, 0, 0, 10634, 10635, 3, 886, 443, + 0, 10635, 10636, 5, 1110, 0, 0, 10636, 10641, 3, 886, 443, 0, 10637, 10638, + 5, 1110, 0, 0, 10638, 10640, 3, 886, 443, 0, 10639, 10637, 1, 0, 0, 0, + 10640, 10643, 1, 0, 0, 0, 10641, 10639, 1, 0, 0, 0, 10641, 10642, 1, 0, + 0, 0, 10642, 10644, 1, 0, 0, 0, 10643, 10641, 1, 0, 0, 0, 10644, 10645, + 5, 1105, 0, 0, 10645, 10663, 1, 0, 0, 0, 10646, 10647, 3, 870, 435, 0, + 10647, 10648, 5, 1104, 0, 0, 10648, 10649, 3, 886, 443, 0, 10649, 10650, + 5, 1110, 0, 0, 10650, 10651, 3, 886, 443, 0, 10651, 10652, 5, 1110, 0, + 0, 10652, 10653, 3, 886, 443, 0, 10653, 10654, 5, 1105, 0, 0, 10654, 10663, + 1, 0, 0, 0, 10655, 10663, 3, 1056, 528, 0, 10656, 10663, 3, 892, 446, 0, + 10657, 10658, 3, 878, 439, 0, 10658, 10659, 5, 1099, 0, 0, 10659, 10660, + 5, 506, 0, 0, 10660, 10663, 1, 0, 0, 0, 10661, 10663, 3, 890, 445, 0, 10662, + 10605, 1, 0, 0, 0, 10662, 10607, 1, 0, 0, 0, 10662, 10608, 1, 0, 0, 0, + 10662, 10609, 1, 0, 0, 0, 10662, 10610, 1, 0, 0, 0, 10662, 10611, 1, 0, + 0, 0, 10662, 10612, 1, 0, 0, 0, 10662, 10614, 1, 0, 0, 0, 10662, 10616, + 1, 0, 0, 0, 10662, 10617, 1, 0, 0, 0, 10662, 10624, 1, 0, 0, 0, 10662, + 10625, 1, 0, 0, 0, 10662, 10632, 1, 0, 0, 0, 10662, 10646, 1, 0, 0, 0, + 10662, 10655, 1, 0, 0, 0, 10662, 10656, 1, 0, 0, 0, 10662, 10657, 1, 0, + 0, 0, 10662, 10661, 1, 0, 0, 0, 10663, 10749, 1, 0, 0, 0, 10664, 10665, + 10, 24, 0, 0, 10665, 10666, 7, 73, 0, 0, 10666, 10748, 3, 886, 443, 25, + 10667, 10668, 10, 23, 0, 0, 10668, 10669, 7, 74, 0, 0, 10669, 10748, 3, + 886, 443, 24, 10670, 10671, 10, 22, 0, 0, 10671, 10672, 7, 75, 0, 0, 10672, + 10748, 3, 886, 443, 23, 10673, 10674, 10, 19, 0, 0, 10674, 10675, 5, 1112, + 0, 0, 10675, 10748, 3, 886, 443, 20, 10676, 10677, 10, 6, 0, 0, 10677, + 10678, 3, 1052, 526, 0, 10678, 10679, 3, 886, 443, 7, 10679, 10748, 1, + 0, 0, 0, 10680, 10682, 10, 2, 0, 0, 10681, 10683, 5, 511, 0, 0, 10682, + 10681, 1, 0, 0, 0, 10682, 10683, 1, 0, 0, 0, 10683, 10684, 1, 0, 0, 0, + 10684, 10685, 5, 717, 0, 0, 10685, 10748, 3, 886, 443, 3, 10686, 10687, + 10, 31, 0, 0, 10687, 10688, 5, 155, 0, 0, 10688, 10748, 3, 852, 426, 0, + 10689, 10690, 10, 21, 0, 0, 10690, 10691, 5, 1106, 0, 0, 10691, 10692, + 3, 886, 443, 0, 10692, 10693, 5, 1107, 0, 0, 10693, 10748, 1, 0, 0, 0, + 10694, 10695, 10, 18, 0, 0, 10695, 10696, 5, 1099, 0, 0, 10696, 10748, + 5, 998, 0, 0, 10697, 10698, 10, 17, 0, 0, 10698, 10699, 5, 1113, 0, 0, + 10699, 10748, 3, 902, 451, 0, 10700, 10701, 10, 16, 0, 0, 10701, 10748, + 3, 910, 455, 0, 10702, 10703, 10, 5, 0, 0, 10703, 10704, 5, 398, 0, 0, + 10704, 10748, 3, 1054, 527, 0, 10705, 10707, 10, 4, 0, 0, 10706, 10708, + 5, 511, 0, 0, 10707, 10706, 1, 0, 0, 0, 10707, 10708, 1, 0, 0, 0, 10708, + 10709, 1, 0, 0, 0, 10709, 10710, 5, 380, 0, 0, 10710, 10713, 5, 1104, 0, + 0, 10711, 10714, 3, 1056, 528, 0, 10712, 10714, 3, 882, 441, 0, 10713, + 10711, 1, 0, 0, 0, 10713, 10712, 1, 0, 0, 0, 10714, 10715, 1, 0, 0, 0, + 10715, 10716, 5, 1105, 0, 0, 10716, 10748, 1, 0, 0, 0, 10717, 10719, 10, + 3, 0, 0, 10718, 10720, 5, 511, 0, 0, 10719, 10718, 1, 0, 0, 0, 10719, 10720, + 1, 0, 0, 0, 10720, 10721, 1, 0, 0, 0, 10721, 10722, 7, 76, 0, 0, 10722, + 10725, 3, 886, 443, 0, 10723, 10724, 5, 278, 0, 0, 10724, 10726, 3, 886, + 443, 0, 10725, 10723, 1, 0, 0, 0, 10725, 10726, 1, 0, 0, 0, 10726, 10748, + 1, 0, 0, 0, 10727, 10729, 10, 1, 0, 0, 10728, 10730, 5, 511, 0, 0, 10729, + 10728, 1, 0, 0, 0, 10729, 10730, 1, 0, 0, 0, 10730, 10731, 1, 0, 0, 0, + 10731, 10732, 7, 76, 0, 0, 10732, 10733, 5, 43, 0, 0, 10733, 10734, 5, + 1104, 0, 0, 10734, 10739, 3, 886, 443, 0, 10735, 10736, 5, 1110, 0, 0, + 10736, 10738, 3, 886, 443, 0, 10737, 10735, 1, 0, 0, 0, 10738, 10741, 1, + 0, 0, 0, 10739, 10737, 1, 0, 0, 0, 10739, 10740, 1, 0, 0, 0, 10740, 10742, + 1, 0, 0, 0, 10741, 10739, 1, 0, 0, 0, 10742, 10745, 5, 1105, 0, 0, 10743, + 10744, 5, 278, 0, 0, 10744, 10746, 3, 886, 443, 0, 10745, 10743, 1, 0, + 0, 0, 10745, 10746, 1, 0, 0, 0, 10746, 10748, 1, 0, 0, 0, 10747, 10664, + 1, 0, 0, 0, 10747, 10667, 1, 0, 0, 0, 10747, 10670, 1, 0, 0, 0, 10747, + 10673, 1, 0, 0, 0, 10747, 10676, 1, 0, 0, 0, 10747, 10680, 1, 0, 0, 0, + 10747, 10686, 1, 0, 0, 0, 10747, 10689, 1, 0, 0, 0, 10747, 10694, 1, 0, + 0, 0, 10747, 10697, 1, 0, 0, 0, 10747, 10700, 1, 0, 0, 0, 10747, 10702, + 1, 0, 0, 0, 10747, 10705, 1, 0, 0, 0, 10747, 10717, 1, 0, 0, 0, 10747, + 10727, 1, 0, 0, 0, 10748, 10751, 1, 0, 0, 0, 10749, 10747, 1, 0, 0, 0, + 10749, 10750, 1, 0, 0, 0, 10750, 887, 1, 0, 0, 0, 10751, 10749, 1, 0, 0, + 0, 10752, 10753, 5, 365, 0, 0, 10753, 10754, 5, 1104, 0, 0, 10754, 10755, + 3, 1050, 525, 0, 10755, 10756, 5, 1110, 0, 0, 10756, 10757, 3, 886, 443, + 0, 10757, 10758, 5, 1110, 0, 0, 10758, 10759, 3, 886, 443, 0, 10759, 10760, + 5, 1105, 0, 0, 10760, 889, 1, 0, 0, 0, 10761, 10762, 7, 77, 0, 0, 10762, + 10763, 5, 1104, 0, 0, 10763, 10768, 3, 886, 443, 0, 10764, 10765, 5, 1110, + 0, 0, 10765, 10767, 3, 852, 426, 0, 10766, 10764, 1, 0, 0, 0, 10767, 10770, + 1, 0, 0, 0, 10768, 10766, 1, 0, 0, 0, 10768, 10769, 1, 0, 0, 0, 10769, + 10771, 1, 0, 0, 0, 10770, 10768, 1, 0, 0, 0, 10771, 10772, 5, 1105, 0, + 0, 10772, 891, 1, 0, 0, 0, 10773, 10774, 5, 949, 0, 0, 10774, 10775, 5, + 1104, 0, 0, 10775, 10776, 3, 886, 443, 0, 10776, 10777, 5, 56, 0, 0, 10777, + 10778, 3, 902, 451, 0, 10778, 10779, 5, 1105, 0, 0, 10779, 893, 1, 0, 0, + 0, 10780, 10781, 5, 1108, 0, 0, 10781, 10786, 3, 896, 448, 0, 10782, 10783, + 5, 1110, 0, 0, 10783, 10785, 3, 896, 448, 0, 10784, 10782, 1, 0, 0, 0, + 10785, 10788, 1, 0, 0, 0, 10786, 10784, 1, 0, 0, 0, 10786, 10787, 1, 0, + 0, 0, 10787, 10789, 1, 0, 0, 0, 10788, 10786, 1, 0, 0, 0, 10789, 10790, + 5, 1109, 0, 0, 10790, 10794, 1, 0, 0, 0, 10791, 10792, 5, 1108, 0, 0, 10792, + 10794, 5, 1109, 0, 0, 10793, 10780, 1, 0, 0, 0, 10793, 10791, 1, 0, 0, + 0, 10794, 895, 1, 0, 0, 0, 10795, 10796, 5, 1083, 0, 0, 10796, 10797, 5, + 1112, 0, 0, 10797, 10798, 3, 898, 449, 0, 10798, 897, 1, 0, 0, 0, 10799, + 10800, 3, 886, 443, 0, 10800, 899, 1, 0, 0, 0, 10801, 10802, 5, 1106, 0, + 0, 10802, 10807, 3, 898, 449, 0, 10803, 10804, 5, 1110, 0, 0, 10804, 10806, + 3, 898, 449, 0, 10805, 10803, 1, 0, 0, 0, 10806, 10809, 1, 0, 0, 0, 10807, + 10805, 1, 0, 0, 0, 10807, 10808, 1, 0, 0, 0, 10808, 10810, 1, 0, 0, 0, + 10809, 10807, 1, 0, 0, 0, 10810, 10811, 5, 1107, 0, 0, 10811, 10815, 1, + 0, 0, 0, 10812, 10813, 5, 1106, 0, 0, 10813, 10815, 5, 1107, 0, 0, 10814, + 10801, 1, 0, 0, 0, 10814, 10812, 1, 0, 0, 0, 10815, 901, 1, 0, 0, 0, 10816, + 10904, 5, 393, 0, 0, 10817, 10904, 5, 1054, 0, 0, 10818, 10904, 5, 1060, + 0, 0, 10819, 10904, 5, 1063, 0, 0, 10820, 10904, 5, 1044, 0, 0, 10821, + 10904, 5, 1041, 0, 0, 10822, 10831, 7, 78, 0, 0, 10823, 10824, 5, 1104, + 0, 0, 10824, 10827, 3, 880, 440, 0, 10825, 10826, 5, 1110, 0, 0, 10826, + 10828, 3, 880, 440, 0, 10827, 10825, 1, 0, 0, 0, 10827, 10828, 1, 0, 0, + 0, 10828, 10829, 1, 0, 0, 0, 10829, 10830, 5, 1105, 0, 0, 10830, 10832, + 1, 0, 0, 0, 10831, 10823, 1, 0, 0, 0, 10831, 10832, 1, 0, 0, 0, 10832, + 10904, 1, 0, 0, 0, 10833, 10904, 5, 1051, 0, 0, 10834, 10904, 5, 1049, + 0, 0, 10835, 10904, 5, 1050, 0, 0, 10836, 10838, 5, 248, 0, 0, 10837, 10839, + 5, 612, 0, 0, 10838, 10837, 1, 0, 0, 0, 10838, 10839, 1, 0, 0, 0, 10839, + 10904, 1, 0, 0, 0, 10840, 10904, 5, 1059, 0, 0, 10841, 10904, 5, 1043, + 0, 0, 10842, 10904, 5, 1046, 0, 0, 10843, 10848, 5, 1047, 0, 0, 10844, + 10845, 5, 1104, 0, 0, 10845, 10846, 3, 880, 440, 0, 10846, 10847, 5, 1105, + 0, 0, 10847, 10849, 1, 0, 0, 0, 10848, 10844, 1, 0, 0, 0, 10848, 10849, + 1, 0, 0, 0, 10849, 10904, 1, 0, 0, 0, 10850, 10855, 5, 899, 0, 0, 10851, + 10852, 5, 1104, 0, 0, 10852, 10853, 3, 880, 440, 0, 10853, 10854, 5, 1105, + 0, 0, 10854, 10856, 1, 0, 0, 0, 10855, 10851, 1, 0, 0, 0, 10855, 10856, + 1, 0, 0, 0, 10856, 10904, 1, 0, 0, 0, 10857, 10862, 5, 904, 0, 0, 10858, + 10859, 5, 1104, 0, 0, 10859, 10860, 3, 880, 440, 0, 10860, 10861, 5, 1105, + 0, 0, 10861, 10863, 1, 0, 0, 0, 10862, 10858, 1, 0, 0, 0, 10862, 10863, + 1, 0, 0, 0, 10863, 10904, 1, 0, 0, 0, 10864, 10869, 5, 908, 0, 0, 10865, + 10866, 5, 1104, 0, 0, 10866, 10867, 3, 880, 440, 0, 10867, 10868, 5, 1105, + 0, 0, 10868, 10870, 1, 0, 0, 0, 10869, 10865, 1, 0, 0, 0, 10869, 10870, + 1, 0, 0, 0, 10870, 10904, 1, 0, 0, 0, 10871, 10876, 5, 910, 0, 0, 10872, + 10873, 5, 1104, 0, 0, 10873, 10874, 3, 880, 440, 0, 10874, 10875, 5, 1105, + 0, 0, 10875, 10877, 1, 0, 0, 0, 10876, 10872, 1, 0, 0, 0, 10876, 10877, + 1, 0, 0, 0, 10877, 10904, 1, 0, 0, 0, 10878, 10883, 5, 914, 0, 0, 10879, + 10880, 5, 1104, 0, 0, 10880, 10881, 3, 880, 440, 0, 10881, 10882, 5, 1105, + 0, 0, 10882, 10884, 1, 0, 0, 0, 10883, 10879, 1, 0, 0, 0, 10883, 10884, + 1, 0, 0, 0, 10884, 10904, 1, 0, 0, 0, 10885, 10904, 5, 1061, 0, 0, 10886, + 10904, 5, 128, 0, 0, 10887, 10904, 5, 129, 0, 0, 10888, 10893, 5, 1065, + 0, 0, 10889, 10890, 5, 1104, 0, 0, 10890, 10891, 3, 880, 440, 0, 10891, + 10892, 5, 1105, 0, 0, 10892, 10894, 1, 0, 0, 0, 10893, 10889, 1, 0, 0, + 0, 10893, 10894, 1, 0, 0, 0, 10894, 10904, 1, 0, 0, 0, 10895, 10904, 5, + 1062, 0, 0, 10896, 10904, 5, 1042, 0, 0, 10897, 10904, 5, 1064, 0, 0, 10898, + 10904, 5, 1066, 0, 0, 10899, 10904, 5, 538, 0, 0, 10900, 10904, 5, 1039, + 0, 0, 10901, 10904, 5, 1052, 0, 0, 10902, 10904, 5, 1053, 0, 0, 10903, + 10816, 1, 0, 0, 0, 10903, 10817, 1, 0, 0, 0, 10903, 10818, 1, 0, 0, 0, + 10903, 10819, 1, 0, 0, 0, 10903, 10820, 1, 0, 0, 0, 10903, 10821, 1, 0, + 0, 0, 10903, 10822, 1, 0, 0, 0, 10903, 10833, 1, 0, 0, 0, 10903, 10834, + 1, 0, 0, 0, 10903, 10835, 1, 0, 0, 0, 10903, 10836, 1, 0, 0, 0, 10903, + 10840, 1, 0, 0, 0, 10903, 10841, 1, 0, 0, 0, 10903, 10842, 1, 0, 0, 0, + 10903, 10843, 1, 0, 0, 0, 10903, 10850, 1, 0, 0, 0, 10903, 10857, 1, 0, + 0, 0, 10903, 10864, 1, 0, 0, 0, 10903, 10871, 1, 0, 0, 0, 10903, 10878, + 1, 0, 0, 0, 10903, 10885, 1, 0, 0, 0, 10903, 10886, 1, 0, 0, 0, 10903, + 10887, 1, 0, 0, 0, 10903, 10888, 1, 0, 0, 0, 10903, 10895, 1, 0, 0, 0, + 10903, 10896, 1, 0, 0, 0, 10903, 10897, 1, 0, 0, 0, 10903, 10898, 1, 0, + 0, 0, 10903, 10899, 1, 0, 0, 0, 10903, 10900, 1, 0, 0, 0, 10903, 10901, + 1, 0, 0, 0, 10903, 10902, 1, 0, 0, 0, 10904, 903, 1, 0, 0, 0, 10905, 10910, + 5, 221, 0, 0, 10906, 10910, 5, 522, 0, 0, 10907, 10910, 3, 856, 428, 0, + 10908, 10910, 3, 918, 459, 0, 10909, 10905, 1, 0, 0, 0, 10909, 10906, 1, + 0, 0, 0, 10909, 10907, 1, 0, 0, 0, 10909, 10908, 1, 0, 0, 0, 10910, 905, + 1, 0, 0, 0, 10911, 10912, 5, 567, 0, 0, 10912, 10913, 5, 110, 0, 0, 10913, + 10914, 3, 884, 442, 0, 10914, 907, 1, 0, 0, 0, 10915, 10916, 7, 79, 0, + 0, 10916, 909, 1, 0, 0, 0, 10917, 10918, 5, 572, 0, 0, 10918, 10919, 5, + 1104, 0, 0, 10919, 10921, 3, 1010, 505, 0, 10920, 10922, 3, 906, 453, 0, + 10921, 10920, 1, 0, 0, 0, 10921, 10922, 1, 0, 0, 0, 10922, 10923, 1, 0, + 0, 0, 10923, 10924, 5, 1105, 0, 0, 10924, 10931, 1, 0, 0, 0, 10925, 10926, + 5, 572, 0, 0, 10926, 10927, 5, 1104, 0, 0, 10927, 10928, 3, 906, 453, 0, + 10928, 10929, 5, 1105, 0, 0, 10929, 10931, 1, 0, 0, 0, 10930, 10917, 1, + 0, 0, 0, 10930, 10925, 1, 0, 0, 0, 10931, 911, 1, 0, 0, 0, 10932, 10962, + 3, 914, 457, 0, 10933, 10962, 3, 916, 458, 0, 10934, 10935, 3, 878, 439, + 0, 10935, 10937, 5, 1104, 0, 0, 10936, 10938, 3, 882, 441, 0, 10937, 10936, + 1, 0, 0, 0, 10937, 10938, 1, 0, 0, 0, 10938, 10939, 1, 0, 0, 0, 10939, + 10940, 5, 1105, 0, 0, 10940, 10962, 1, 0, 0, 0, 10941, 10942, 3, 864, 432, + 0, 10942, 10943, 5, 1104, 0, 0, 10943, 10944, 3, 882, 441, 0, 10944, 10945, + 5, 1105, 0, 0, 10945, 10962, 1, 0, 0, 0, 10946, 10947, 7, 68, 0, 0, 10947, + 10948, 5, 1104, 0, 0, 10948, 10949, 3, 886, 443, 0, 10949, 10950, 5, 1105, + 0, 0, 10950, 10962, 1, 0, 0, 0, 10951, 10952, 7, 80, 0, 0, 10952, 10953, + 5, 1104, 0, 0, 10953, 10954, 3, 886, 443, 0, 10954, 10955, 5, 1105, 0, + 0, 10955, 10962, 1, 0, 0, 0, 10956, 10957, 5, 923, 0, 0, 10957, 10958, + 5, 1104, 0, 0, 10958, 10959, 3, 886, 443, 0, 10959, 10960, 5, 1105, 0, + 0, 10960, 10962, 1, 0, 0, 0, 10961, 10932, 1, 0, 0, 0, 10961, 10933, 1, + 0, 0, 0, 10961, 10934, 1, 0, 0, 0, 10961, 10941, 1, 0, 0, 0, 10961, 10946, + 1, 0, 0, 0, 10961, 10951, 1, 0, 0, 0, 10961, 10956, 1, 0, 0, 0, 10962, + 913, 1, 0, 0, 0, 10963, 10964, 7, 81, 0, 0, 10964, 10965, 5, 1104, 0, 0, + 10965, 10966, 5, 1105, 0, 0, 10966, 10974, 3, 910, 455, 0, 10967, 10968, + 5, 519, 0, 0, 10968, 10969, 5, 1104, 0, 0, 10969, 10970, 3, 886, 443, 0, + 10970, 10971, 5, 1105, 0, 0, 10971, 10972, 3, 910, 455, 0, 10972, 10974, + 1, 0, 0, 0, 10973, 10963, 1, 0, 0, 0, 10973, 10967, 1, 0, 0, 0, 10974, + 915, 1, 0, 0, 0, 10975, 10976, 3, 856, 428, 0, 10976, 10978, 5, 1104, 0, + 0, 10977, 10979, 5, 245, 0, 0, 10978, 10977, 1, 0, 0, 0, 10978, 10979, + 1, 0, 0, 0, 10979, 10980, 1, 0, 0, 0, 10980, 10981, 3, 882, 441, 0, 10981, + 10982, 5, 1105, 0, 0, 10982, 11008, 1, 0, 0, 0, 10983, 10984, 3, 856, 428, + 0, 10984, 10985, 5, 1104, 0, 0, 10985, 10986, 5, 1114, 0, 0, 10986, 10987, + 5, 1105, 0, 0, 10987, 11008, 1, 0, 0, 0, 10988, 10989, 5, 1067, 0, 0, 10989, + 10991, 5, 1104, 0, 0, 10990, 10992, 5, 245, 0, 0, 10991, 10990, 1, 0, 0, + 0, 10991, 10992, 1, 0, 0, 0, 10992, 10993, 1, 0, 0, 0, 10993, 10996, 3, + 886, 443, 0, 10994, 10995, 5, 1110, 0, 0, 10995, 10997, 3, 852, 426, 0, + 10996, 10994, 1, 0, 0, 0, 10996, 10997, 1, 0, 0, 0, 10997, 10998, 1, 0, + 0, 0, 10998, 11005, 5, 1105, 0, 0, 10999, 11000, 5, 1021, 0, 0, 11000, + 11001, 5, 350, 0, 0, 11001, 11002, 5, 1104, 0, 0, 11002, 11003, 3, 1072, + 536, 0, 11003, 11004, 5, 1105, 0, 0, 11004, 11006, 1, 0, 0, 0, 11005, 10999, + 1, 0, 0, 0, 11005, 11006, 1, 0, 0, 0, 11006, 11008, 1, 0, 0, 0, 11007, + 10975, 1, 0, 0, 0, 11007, 10983, 1, 0, 0, 0, 11007, 10988, 1, 0, 0, 0, + 11008, 917, 1, 0, 0, 0, 11009, 11022, 5, 1083, 0, 0, 11010, 11012, 3, 920, + 460, 0, 11011, 11010, 1, 0, 0, 0, 11011, 11012, 1, 0, 0, 0, 11012, 11013, + 1, 0, 0, 0, 11013, 11022, 5, 1084, 0, 0, 11014, 11016, 3, 920, 460, 0, + 11015, 11014, 1, 0, 0, 0, 11015, 11016, 1, 0, 0, 0, 11016, 11017, 1, 0, + 0, 0, 11017, 11022, 7, 82, 0, 0, 11018, 11022, 3, 450, 225, 0, 11019, 11022, + 5, 522, 0, 0, 11020, 11022, 5, 1102, 0, 0, 11021, 11009, 1, 0, 0, 0, 11021, + 11011, 1, 0, 0, 0, 11021, 11015, 1, 0, 0, 0, 11021, 11018, 1, 0, 0, 0, + 11021, 11019, 1, 0, 0, 0, 11021, 11020, 1, 0, 0, 0, 11022, 919, 1, 0, 0, + 0, 11023, 11024, 7, 72, 0, 0, 11024, 921, 1, 0, 0, 0, 11025, 11027, 3, + 856, 428, 0, 11026, 11025, 1, 0, 0, 0, 11026, 11027, 1, 0, 0, 0, 11027, + 11028, 1, 0, 0, 0, 11028, 11030, 5, 1099, 0, 0, 11029, 11031, 3, 856, 428, + 0, 11030, 11029, 1, 0, 0, 0, 11030, 11031, 1, 0, 0, 0, 11031, 11032, 1, + 0, 0, 0, 11032, 11034, 5, 1099, 0, 0, 11033, 11035, 3, 856, 428, 0, 11034, + 11033, 1, 0, 0, 0, 11034, 11035, 1, 0, 0, 0, 11035, 11036, 1, 0, 0, 0, + 11036, 11037, 5, 1099, 0, 0, 11037, 11054, 3, 856, 428, 0, 11038, 11040, + 3, 856, 428, 0, 11039, 11038, 1, 0, 0, 0, 11039, 11040, 1, 0, 0, 0, 11040, + 11041, 1, 0, 0, 0, 11041, 11043, 5, 1099, 0, 0, 11042, 11044, 3, 856, 428, + 0, 11043, 11042, 1, 0, 0, 0, 11043, 11044, 1, 0, 0, 0, 11044, 11045, 1, + 0, 0, 0, 11045, 11046, 5, 1099, 0, 0, 11046, 11054, 3, 856, 428, 0, 11047, + 11049, 3, 856, 428, 0, 11048, 11047, 1, 0, 0, 0, 11048, 11049, 1, 0, 0, + 0, 11049, 11050, 1, 0, 0, 0, 11050, 11051, 5, 1099, 0, 0, 11051, 11054, + 3, 856, 428, 0, 11052, 11054, 3, 856, 428, 0, 11053, 11026, 1, 0, 0, 0, + 11053, 11039, 1, 0, 0, 0, 11053, 11048, 1, 0, 0, 0, 11053, 11052, 1, 0, + 0, 0, 11054, 923, 1, 0, 0, 0, 11055, 11056, 5, 1104, 0, 0, 11056, 11057, + 3, 886, 443, 0, 11057, 11058, 5, 1105, 0, 0, 11058, 11064, 1, 0, 0, 0, + 11059, 11060, 5, 1104, 0, 0, 11060, 11061, 3, 1056, 528, 0, 11061, 11062, + 5, 1105, 0, 0, 11062, 11064, 1, 0, 0, 0, 11063, 11055, 1, 0, 0, 0, 11063, + 11059, 1, 0, 0, 0, 11064, 925, 1, 0, 0, 0, 11065, 11066, 5, 117, 0, 0, + 11066, 11068, 3, 886, 443, 0, 11067, 11069, 3, 930, 465, 0, 11068, 11067, + 1, 0, 0, 0, 11069, 11070, 1, 0, 0, 0, 11070, 11068, 1, 0, 0, 0, 11070, + 11071, 1, 0, 0, 0, 11071, 11074, 1, 0, 0, 0, 11072, 11073, 5, 253, 0, 0, + 11073, 11075, 3, 886, 443, 0, 11074, 11072, 1, 0, 0, 0, 11074, 11075, 1, + 0, 0, 0, 11075, 11076, 1, 0, 0, 0, 11076, 11077, 5, 266, 0, 0, 11077, 11091, + 1, 0, 0, 0, 11078, 11080, 5, 117, 0, 0, 11079, 11081, 3, 928, 464, 0, 11080, + 11079, 1, 0, 0, 0, 11081, 11082, 1, 0, 0, 0, 11082, 11080, 1, 0, 0, 0, + 11082, 11083, 1, 0, 0, 0, 11083, 11086, 1, 0, 0, 0, 11084, 11085, 5, 253, + 0, 0, 11085, 11087, 3, 886, 443, 0, 11086, 11084, 1, 0, 0, 0, 11086, 11087, + 1, 0, 0, 0, 11087, 11088, 1, 0, 0, 0, 11088, 11089, 5, 266, 0, 0, 11089, + 11091, 1, 0, 0, 0, 11090, 11065, 1, 0, 0, 0, 11090, 11078, 1, 0, 0, 0, + 11091, 927, 1, 0, 0, 0, 11092, 11093, 5, 1018, 0, 0, 11093, 11094, 3, 1050, + 525, 0, 11094, 11095, 5, 897, 0, 0, 11095, 11096, 3, 886, 443, 0, 11096, + 929, 1, 0, 0, 0, 11097, 11098, 5, 1018, 0, 0, 11098, 11099, 3, 886, 443, + 0, 11099, 11100, 5, 897, 0, 0, 11100, 11101, 3, 886, 443, 0, 11101, 931, + 1, 0, 0, 0, 11102, 11104, 3, 934, 467, 0, 11103, 11102, 1, 0, 0, 0, 11103, + 11104, 1, 0, 0, 0, 11104, 11105, 1, 0, 0, 0, 11105, 11109, 3, 942, 471, + 0, 11106, 11108, 3, 944, 472, 0, 11107, 11106, 1, 0, 0, 0, 11108, 11111, + 1, 0, 0, 0, 11109, 11107, 1, 0, 0, 0, 11109, 11110, 1, 0, 0, 0, 11110, + 933, 1, 0, 0, 0, 11111, 11109, 1, 0, 0, 0, 11112, 11113, 5, 1020, 0, 0, + 11113, 11118, 3, 936, 468, 0, 11114, 11115, 5, 1110, 0, 0, 11115, 11117, + 3, 936, 468, 0, 11116, 11114, 1, 0, 0, 0, 11117, 11120, 1, 0, 0, 0, 11118, + 11116, 1, 0, 0, 0, 11118, 11119, 1, 0, 0, 0, 11119, 935, 1, 0, 0, 0, 11120, + 11118, 1, 0, 0, 0, 11121, 11123, 5, 667, 0, 0, 11122, 11121, 1, 0, 0, 0, + 11122, 11123, 1, 0, 0, 0, 11123, 11124, 1, 0, 0, 0, 11124, 11129, 3, 856, + 428, 0, 11125, 11126, 5, 1104, 0, 0, 11126, 11127, 3, 876, 438, 0, 11127, + 11128, 5, 1105, 0, 0, 11128, 11130, 1, 0, 0, 0, 11129, 11125, 1, 0, 0, + 0, 11129, 11130, 1, 0, 0, 0, 11130, 11131, 1, 0, 0, 0, 11131, 11132, 5, + 56, 0, 0, 11132, 11133, 5, 1104, 0, 0, 11133, 11134, 3, 938, 469, 0, 11134, + 11135, 5, 965, 0, 0, 11135, 11136, 5, 23, 0, 0, 11136, 11137, 3, 940, 470, + 0, 11137, 11138, 5, 1105, 0, 0, 11138, 11152, 1, 0, 0, 0, 11139, 11144, + 3, 856, 428, 0, 11140, 11141, 5, 1104, 0, 0, 11141, 11142, 3, 876, 438, + 0, 11142, 11143, 5, 1105, 0, 0, 11143, 11145, 1, 0, 0, 0, 11144, 11140, + 1, 0, 0, 0, 11144, 11145, 1, 0, 0, 0, 11145, 11146, 1, 0, 0, 0, 11146, + 11147, 5, 56, 0, 0, 11147, 11148, 5, 1104, 0, 0, 11148, 11149, 3, 932, + 466, 0, 11149, 11150, 5, 1105, 0, 0, 11150, 11152, 1, 0, 0, 0, 11151, 11122, + 1, 0, 0, 0, 11151, 11139, 1, 0, 0, 0, 11152, 937, 1, 0, 0, 0, 11153, 11154, + 3, 932, 466, 0, 11154, 939, 1, 0, 0, 0, 11155, 11156, 3, 932, 466, 0, 11156, + 941, 1, 0, 0, 0, 11157, 11158, 3, 948, 474, 0, 11158, 11160, 3, 946, 473, + 0, 11159, 11161, 3, 1078, 539, 0, 11160, 11159, 1, 0, 0, 0, 11160, 11161, + 1, 0, 0, 0, 11161, 11166, 1, 0, 0, 0, 11162, 11163, 3, 950, 475, 0, 11163, + 11164, 3, 946, 473, 0, 11164, 11166, 1, 0, 0, 0, 11165, 11157, 1, 0, 0, + 0, 11165, 11162, 1, 0, 0, 0, 11166, 943, 1, 0, 0, 0, 11167, 11169, 5, 965, + 0, 0, 11168, 11170, 5, 23, 0, 0, 11169, 11168, 1, 0, 0, 0, 11169, 11170, + 1, 0, 0, 0, 11170, 11174, 1, 0, 0, 0, 11171, 11174, 7, 83, 0, 0, 11172, + 11174, 5, 396, 0, 0, 11173, 11167, 1, 0, 0, 0, 11173, 11171, 1, 0, 0, 0, + 11173, 11172, 1, 0, 0, 0, 11174, 11175, 1, 0, 0, 0, 11175, 11181, 3, 942, + 471, 0, 11176, 11177, 5, 1104, 0, 0, 11177, 11178, 3, 942, 471, 0, 11178, + 11179, 5, 1105, 0, 0, 11179, 11181, 1, 0, 0, 0, 11180, 11173, 1, 0, 0, + 0, 11180, 11176, 1, 0, 0, 0, 11181, 945, 1, 0, 0, 0, 11182, 11184, 3, 972, + 486, 0, 11183, 11182, 1, 0, 0, 0, 11183, 11184, 1, 0, 0, 0, 11184, 11186, + 1, 0, 0, 0, 11185, 11187, 3, 978, 489, 0, 11186, 11185, 1, 0, 0, 0, 11186, + 11187, 1, 0, 0, 0, 11187, 11189, 1, 0, 0, 0, 11188, 11190, 3, 1060, 530, + 0, 11189, 11188, 1, 0, 0, 0, 11189, 11190, 1, 0, 0, 0, 11190, 11192, 1, + 0, 0, 0, 11191, 11193, 3, 1064, 532, 0, 11192, 11191, 1, 0, 0, 0, 11192, + 11193, 1, 0, 0, 0, 11193, 11195, 1, 0, 0, 0, 11194, 11196, 3, 1068, 534, + 0, 11195, 11194, 1, 0, 0, 0, 11195, 11196, 1, 0, 0, 0, 11196, 11198, 1, + 0, 0, 0, 11197, 11199, 3, 1072, 536, 0, 11198, 11197, 1, 0, 0, 0, 11198, + 11199, 1, 0, 0, 0, 11199, 947, 1, 0, 0, 0, 11200, 11201, 5, 773, 0, 0, + 11201, 11202, 3, 952, 476, 0, 11202, 949, 1, 0, 0, 0, 11203, 11204, 5, + 773, 0, 0, 11204, 11205, 3, 954, 477, 0, 11205, 951, 1, 0, 0, 0, 11206, + 11208, 3, 968, 484, 0, 11207, 11206, 1, 0, 0, 0, 11207, 11208, 1, 0, 0, + 0, 11208, 11209, 1, 0, 0, 0, 11209, 11210, 3, 956, 478, 0, 11210, 953, + 1, 0, 0, 0, 11211, 11213, 3, 968, 484, 0, 11212, 11211, 1, 0, 0, 0, 11212, + 11213, 1, 0, 0, 0, 11213, 11214, 1, 0, 0, 0, 11214, 11215, 3, 970, 485, + 0, 11215, 11216, 3, 956, 478, 0, 11216, 955, 1, 0, 0, 0, 11217, 11222, + 3, 958, 479, 0, 11218, 11219, 5, 1110, 0, 0, 11219, 11221, 3, 958, 479, + 0, 11220, 11218, 1, 0, 0, 0, 11221, 11224, 1, 0, 0, 0, 11222, 11220, 1, + 0, 0, 0, 11222, 11223, 1, 0, 0, 0, 11223, 957, 1, 0, 0, 0, 11224, 11222, + 1, 0, 0, 0, 11225, 11228, 3, 960, 480, 0, 11226, 11228, 3, 964, 482, 0, + 11227, 11225, 1, 0, 0, 0, 11227, 11226, 1, 0, 0, 0, 11228, 959, 1, 0, 0, + 0, 11229, 11234, 3, 878, 439, 0, 11230, 11231, 3, 1012, 506, 0, 11231, + 11232, 5, 1099, 0, 0, 11232, 11234, 1, 0, 0, 0, 11233, 11229, 1, 0, 0, + 0, 11233, 11230, 1, 0, 0, 0, 11233, 11234, 1, 0, 0, 0, 11234, 11235, 1, + 0, 0, 0, 11235, 11258, 5, 1114, 0, 0, 11236, 11241, 3, 878, 439, 0, 11237, + 11238, 3, 1012, 506, 0, 11238, 11239, 5, 1099, 0, 0, 11239, 11241, 1, 0, + 0, 0, 11240, 11236, 1, 0, 0, 0, 11240, 11237, 1, 0, 0, 0, 11240, 11241, + 1, 0, 0, 0, 11241, 11242, 1, 0, 0, 0, 11242, 11244, 3, 874, 437, 0, 11243, + 11245, 3, 962, 481, 0, 11244, 11243, 1, 0, 0, 0, 11244, 11245, 1, 0, 0, + 0, 11245, 11258, 1, 0, 0, 0, 11246, 11251, 3, 878, 439, 0, 11247, 11248, + 3, 1012, 506, 0, 11248, 11249, 5, 1099, 0, 0, 11249, 11251, 1, 0, 0, 0, + 11250, 11246, 1, 0, 0, 0, 11250, 11247, 1, 0, 0, 0, 11250, 11251, 1, 0, + 0, 0, 11251, 11252, 1, 0, 0, 0, 11252, 11253, 5, 1103, 0, 0, 11253, 11255, + 3, 966, 483, 0, 11254, 11256, 3, 962, 481, 0, 11255, 11254, 1, 0, 0, 0, + 11255, 11256, 1, 0, 0, 0, 11256, 11258, 1, 0, 0, 0, 11257, 11233, 1, 0, + 0, 0, 11257, 11240, 1, 0, 0, 0, 11257, 11250, 1, 0, 0, 0, 11258, 961, 1, + 0, 0, 0, 11259, 11261, 5, 56, 0, 0, 11260, 11259, 1, 0, 0, 0, 11260, 11261, + 1, 0, 0, 0, 11261, 11262, 1, 0, 0, 0, 11262, 11263, 3, 1012, 506, 0, 11263, + 963, 1, 0, 0, 0, 11264, 11267, 3, 886, 443, 0, 11265, 11267, 3, 1058, 529, + 0, 11266, 11264, 1, 0, 0, 0, 11266, 11265, 1, 0, 0, 0, 11267, 11269, 1, + 0, 0, 0, 11268, 11270, 3, 962, 481, 0, 11269, 11268, 1, 0, 0, 0, 11269, + 11270, 1, 0, 0, 0, 11270, 965, 1, 0, 0, 0, 11271, 11272, 3, 880, 440, 0, + 11272, 967, 1, 0, 0, 0, 11273, 11274, 7, 84, 0, 0, 11274, 969, 1, 0, 0, + 0, 11275, 11276, 5, 925, 0, 0, 11276, 11277, 3, 880, 440, 0, 11277, 971, + 1, 0, 0, 0, 11278, 11279, 5, 397, 0, 0, 11279, 11280, 3, 974, 487, 0, 11280, + 973, 1, 0, 0, 0, 11281, 11282, 3, 976, 488, 0, 11282, 11283, 5, 1110, 0, + 0, 11283, 11284, 3, 976, 488, 0, 11284, 975, 1, 0, 0, 0, 11285, 11286, + 5, 1112, 0, 0, 11286, 11287, 3, 856, 428, 0, 11287, 977, 1, 0, 0, 0, 11288, + 11289, 5, 329, 0, 0, 11289, 11290, 3, 980, 490, 0, 11290, 979, 1, 0, 0, + 0, 11291, 11296, 3, 982, 491, 0, 11292, 11293, 5, 1110, 0, 0, 11293, 11295, + 3, 982, 491, 0, 11294, 11292, 1, 0, 0, 0, 11295, 11298, 1, 0, 0, 0, 11296, + 11294, 1, 0, 0, 0, 11296, 11297, 1, 0, 0, 0, 11297, 981, 1, 0, 0, 0, 11298, + 11296, 1, 0, 0, 0, 11299, 11300, 3, 984, 492, 0, 11300, 983, 1, 0, 0, 0, + 11301, 11305, 3, 986, 493, 0, 11302, 11304, 3, 1000, 500, 0, 11303, 11302, + 1, 0, 0, 0, 11304, 11307, 1, 0, 0, 0, 11305, 11303, 1, 0, 0, 0, 11305, + 11306, 1, 0, 0, 0, 11306, 11318, 1, 0, 0, 0, 11307, 11305, 1, 0, 0, 0, + 11308, 11309, 5, 1104, 0, 0, 11309, 11310, 3, 984, 492, 0, 11310, 11314, + 5, 1105, 0, 0, 11311, 11313, 3, 1000, 500, 0, 11312, 11311, 1, 0, 0, 0, + 11313, 11316, 1, 0, 0, 0, 11314, 11312, 1, 0, 0, 0, 11314, 11315, 1, 0, + 0, 0, 11315, 11318, 1, 0, 0, 0, 11316, 11314, 1, 0, 0, 0, 11317, 11301, + 1, 0, 0, 0, 11317, 11308, 1, 0, 0, 0, 11318, 985, 1, 0, 0, 0, 11319, 11321, + 3, 878, 439, 0, 11320, 11322, 3, 1002, 501, 0, 11321, 11320, 1, 0, 0, 0, + 11321, 11322, 1, 0, 0, 0, 11322, 11324, 1, 0, 0, 0, 11323, 11325, 3, 1006, + 503, 0, 11324, 11323, 1, 0, 0, 0, 11324, 11325, 1, 0, 0, 0, 11325, 11327, + 1, 0, 0, 0, 11326, 11328, 3, 1032, 516, 0, 11327, 11326, 1, 0, 0, 0, 11327, + 11328, 1, 0, 0, 0, 11328, 11330, 1, 0, 0, 0, 11329, 11331, 3, 1034, 517, + 0, 11330, 11329, 1, 0, 0, 0, 11330, 11331, 1, 0, 0, 0, 11331, 11333, 1, + 0, 0, 0, 11332, 11334, 3, 962, 481, 0, 11333, 11332, 1, 0, 0, 0, 11333, + 11334, 1, 0, 0, 0, 11334, 11336, 1, 0, 0, 0, 11335, 11337, 3, 1048, 524, + 0, 11336, 11335, 1, 0, 0, 0, 11336, 11337, 1, 0, 0, 0, 11337, 11387, 1, + 0, 0, 0, 11338, 11339, 3, 878, 439, 0, 11339, 11340, 5, 828, 0, 0, 11340, + 11341, 5, 1020, 0, 0, 11341, 11342, 3, 1058, 529, 0, 11342, 11343, 5, 171, + 0, 0, 11343, 11345, 5, 110, 0, 0, 11344, 11346, 3, 992, 496, 0, 11345, + 11344, 1, 0, 0, 0, 11345, 11346, 1, 0, 0, 0, 11346, 11387, 1, 0, 0, 0, + 11347, 11348, 5, 880, 0, 0, 11348, 11349, 5, 1104, 0, 0, 11349, 11350, + 3, 878, 439, 0, 11350, 11351, 5, 1104, 0, 0, 11351, 11352, 3, 882, 441, + 0, 11352, 11353, 5, 1105, 0, 0, 11353, 11355, 5, 1105, 0, 0, 11354, 11356, + 3, 1034, 517, 0, 11355, 11354, 1, 0, 0, 0, 11355, 11356, 1, 0, 0, 0, 11356, + 11358, 1, 0, 0, 0, 11357, 11359, 3, 962, 481, 0, 11358, 11357, 1, 0, 0, + 0, 11358, 11359, 1, 0, 0, 0, 11359, 11361, 1, 0, 0, 0, 11360, 11362, 3, + 1048, 524, 0, 11361, 11360, 1, 0, 0, 0, 11361, 11362, 1, 0, 0, 0, 11362, + 11387, 1, 0, 0, 0, 11363, 11364, 5, 1104, 0, 0, 11364, 11365, 3, 1040, + 520, 0, 11365, 11367, 5, 1105, 0, 0, 11366, 11368, 3, 1048, 524, 0, 11367, + 11366, 1, 0, 0, 0, 11367, 11368, 1, 0, 0, 0, 11368, 11387, 1, 0, 0, 0, + 11369, 11371, 5, 424, 0, 0, 11370, 11369, 1, 0, 0, 0, 11370, 11371, 1, + 0, 0, 0, 11371, 11372, 1, 0, 0, 0, 11372, 11373, 5, 1104, 0, 0, 11373, + 11374, 3, 1056, 528, 0, 11374, 11376, 5, 1105, 0, 0, 11375, 11377, 3, 1034, + 517, 0, 11376, 11375, 1, 0, 0, 0, 11376, 11377, 1, 0, 0, 0, 11377, 11379, + 1, 0, 0, 0, 11378, 11380, 3, 962, 481, 0, 11379, 11378, 1, 0, 0, 0, 11379, + 11380, 1, 0, 0, 0, 11380, 11387, 1, 0, 0, 0, 11381, 11382, 5, 424, 0, 0, + 11382, 11384, 3, 990, 495, 0, 11383, 11385, 3, 962, 481, 0, 11384, 11383, + 1, 0, 0, 0, 11384, 11385, 1, 0, 0, 0, 11385, 11387, 1, 0, 0, 0, 11386, + 11319, 1, 0, 0, 0, 11386, 11338, 1, 0, 0, 0, 11386, 11347, 1, 0, 0, 0, + 11386, 11363, 1, 0, 0, 0, 11386, 11370, 1, 0, 0, 0, 11386, 11381, 1, 0, + 0, 0, 11387, 987, 1, 0, 0, 0, 11388, 11389, 5, 589, 0, 0, 11389, 11390, + 5, 1089, 0, 0, 11390, 11401, 3, 852, 426, 0, 11391, 11392, 5, 571, 0, 0, + 11392, 11393, 5, 1089, 0, 0, 11393, 11401, 3, 450, 225, 0, 11394, 11395, + 5, 667, 0, 0, 11395, 11396, 5, 1089, 0, 0, 11396, 11401, 3, 450, 225, 0, + 11397, 11398, 5, 481, 0, 0, 11398, 11399, 5, 1089, 0, 0, 11399, 11401, + 7, 85, 0, 0, 11400, 11388, 1, 0, 0, 0, 11400, 11391, 1, 0, 0, 0, 11400, + 11394, 1, 0, 0, 0, 11400, 11397, 1, 0, 0, 0, 11401, 989, 1, 0, 0, 0, 11402, + 11403, 5, 321, 0, 0, 11403, 11406, 5, 1104, 0, 0, 11404, 11405, 5, 389, + 0, 0, 11405, 11407, 5, 1089, 0, 0, 11406, 11404, 1, 0, 0, 0, 11406, 11407, + 1, 0, 0, 0, 11407, 11408, 1, 0, 0, 0, 11408, 11413, 3, 886, 443, 0, 11409, + 11410, 5, 1110, 0, 0, 11410, 11412, 3, 988, 494, 0, 11411, 11409, 1, 0, + 0, 0, 11412, 11415, 1, 0, 0, 0, 11413, 11411, 1, 0, 0, 0, 11413, 11414, + 1, 0, 0, 0, 11414, 11416, 1, 0, 0, 0, 11415, 11413, 1, 0, 0, 0, 11416, + 11417, 5, 1105, 0, 0, 11417, 991, 1, 0, 0, 0, 11418, 11423, 3, 994, 497, + 0, 11419, 11420, 5, 1110, 0, 0, 11420, 11422, 3, 994, 497, 0, 11421, 11419, + 1, 0, 0, 0, 11422, 11425, 1, 0, 0, 0, 11423, 11421, 1, 0, 0, 0, 11423, + 11424, 1, 0, 0, 0, 11424, 993, 1, 0, 0, 0, 11425, 11423, 1, 0, 0, 0, 11426, + 11428, 5, 621, 0, 0, 11427, 11426, 1, 0, 0, 0, 11427, 11428, 1, 0, 0, 0, + 11428, 11429, 1, 0, 0, 0, 11429, 11430, 3, 856, 428, 0, 11430, 11432, 5, + 1092, 0, 0, 11431, 11433, 5, 621, 0, 0, 11432, 11431, 1, 0, 0, 0, 11432, + 11433, 1, 0, 0, 0, 11433, 11434, 1, 0, 0, 0, 11434, 11435, 3, 856, 428, + 0, 11435, 995, 1, 0, 0, 0, 11436, 11438, 7, 86, 0, 0, 11437, 11439, 5, + 571, 0, 0, 11438, 11437, 1, 0, 0, 0, 11438, 11439, 1, 0, 0, 0, 11439, 997, + 1, 0, 0, 0, 11440, 11443, 5, 388, 0, 0, 11441, 11443, 3, 996, 498, 0, 11442, + 11440, 1, 0, 0, 0, 11442, 11441, 1, 0, 0, 0, 11443, 999, 1, 0, 0, 0, 11444, + 11446, 3, 998, 499, 0, 11445, 11444, 1, 0, 0, 0, 11445, 11446, 1, 0, 0, + 0, 11446, 11447, 1, 0, 0, 0, 11447, 11448, 5, 406, 0, 0, 11448, 11460, + 3, 986, 493, 0, 11449, 11450, 5, 553, 0, 0, 11450, 11452, 3, 1050, 525, + 0, 11451, 11449, 1, 0, 0, 0, 11451, 11452, 1, 0, 0, 0, 11452, 11461, 1, + 0, 0, 0, 11453, 11454, 5, 992, 0, 0, 11454, 11455, 5, 1104, 0, 0, 11455, + 11456, 3, 876, 438, 0, 11456, 11457, 5, 1105, 0, 0, 11457, 11459, 1, 0, + 0, 0, 11458, 11453, 1, 0, 0, 0, 11458, 11459, 1, 0, 0, 0, 11459, 11461, + 1, 0, 0, 0, 11460, 11451, 1, 0, 0, 0, 11460, 11458, 1, 0, 0, 0, 11461, + 11472, 1, 0, 0, 0, 11462, 11464, 5, 493, 0, 0, 11463, 11465, 3, 996, 498, + 0, 11464, 11463, 1, 0, 0, 0, 11464, 11465, 1, 0, 0, 0, 11465, 11466, 1, + 0, 0, 0, 11466, 11467, 5, 406, 0, 0, 11467, 11472, 3, 986, 493, 0, 11468, + 11469, 5, 193, 0, 0, 11469, 11470, 5, 406, 0, 0, 11470, 11472, 3, 986, + 493, 0, 11471, 11445, 1, 0, 0, 0, 11471, 11462, 1, 0, 0, 0, 11471, 11468, + 1, 0, 0, 0, 11472, 1001, 1, 0, 0, 0, 11473, 11474, 5, 59, 0, 0, 11474, + 11487, 5, 1104, 0, 0, 11475, 11476, 5, 904, 0, 0, 11476, 11477, 5, 1089, + 0, 0, 11477, 11488, 3, 886, 443, 0, 11478, 11479, 5, 544, 0, 0, 11479, + 11480, 5, 1089, 0, 0, 11480, 11488, 3, 886, 443, 0, 11481, 11482, 5, 834, + 0, 0, 11482, 11483, 5, 1089, 0, 0, 11483, 11488, 3, 852, 426, 0, 11484, + 11485, 5, 857, 0, 0, 11485, 11486, 5, 1089, 0, 0, 11486, 11488, 3, 852, + 426, 0, 11487, 11475, 1, 0, 0, 0, 11487, 11478, 1, 0, 0, 0, 11487, 11481, + 1, 0, 0, 0, 11487, 11484, 1, 0, 0, 0, 11488, 11489, 1, 0, 0, 0, 11489, + 11490, 5, 1105, 0, 0, 11490, 11499, 1, 0, 0, 0, 11491, 11492, 5, 93, 0, + 0, 11492, 11493, 5, 1104, 0, 0, 11493, 11494, 5, 834, 0, 0, 11494, 11495, + 5, 1089, 0, 0, 11495, 11496, 3, 852, 426, 0, 11496, 11497, 5, 1105, 0, + 0, 11497, 11499, 1, 0, 0, 0, 11498, 11473, 1, 0, 0, 0, 11498, 11491, 1, + 0, 0, 0, 11499, 1003, 1, 0, 0, 0, 11500, 11501, 5, 266, 0, 0, 11501, 11502, + 5, 1104, 0, 0, 11502, 11503, 5, 904, 0, 0, 11503, 11504, 5, 1088, 0, 0, + 11504, 11514, 3, 852, 426, 0, 11505, 11506, 5, 544, 0, 0, 11506, 11507, + 5, 1088, 0, 0, 11507, 11514, 3, 852, 426, 0, 11508, 11509, 5, 834, 0, 0, + 11509, 11510, 5, 1088, 0, 0, 11510, 11511, 3, 856, 428, 0, 11511, 11512, + 5, 1105, 0, 0, 11512, 11514, 1, 0, 0, 0, 11513, 11500, 1, 0, 0, 0, 11513, + 11505, 1, 0, 0, 0, 11513, 11508, 1, 0, 0, 0, 11514, 1005, 1, 0, 0, 0, 11515, + 11516, 5, 124, 0, 0, 11516, 11517, 5, 1104, 0, 0, 11517, 11518, 5, 383, + 0, 0, 11518, 11519, 5, 1089, 0, 0, 11519, 11520, 3, 1008, 504, 0, 11520, + 11521, 5, 1105, 0, 0, 11521, 11523, 3, 1002, 501, 0, 11522, 11524, 3, 1004, + 502, 0, 11523, 11522, 1, 0, 0, 0, 11523, 11524, 1, 0, 0, 0, 11524, 1007, + 1, 0, 0, 0, 11525, 11529, 5, 221, 0, 0, 11526, 11527, 5, 51, 0, 0, 11527, + 11529, 5, 556, 0, 0, 11528, 11525, 1, 0, 0, 0, 11528, 11526, 1, 0, 0, 0, + 11529, 1009, 1, 0, 0, 0, 11530, 11531, 5, 584, 0, 0, 11531, 11532, 5, 110, + 0, 0, 11532, 11533, 3, 882, 441, 0, 11533, 1011, 1, 0, 0, 0, 11534, 11535, + 3, 856, 428, 0, 11535, 1013, 1, 0, 0, 0, 11536, 11538, 3, 886, 443, 0, + 11537, 11539, 5, 56, 0, 0, 11538, 11537, 1, 0, 0, 0, 11538, 11539, 1, 0, + 0, 0, 11539, 11540, 1, 0, 0, 0, 11540, 11550, 3, 1012, 506, 0, 11541, 11542, + 5, 1110, 0, 0, 11542, 11544, 3, 886, 443, 0, 11543, 11545, 5, 56, 0, 0, + 11544, 11543, 1, 0, 0, 0, 11544, 11545, 1, 0, 0, 0, 11545, 11546, 1, 0, + 0, 0, 11546, 11547, 3, 1012, 506, 0, 11547, 11549, 1, 0, 0, 0, 11548, 11541, + 1, 0, 0, 0, 11549, 11552, 1, 0, 0, 0, 11550, 11548, 1, 0, 0, 0, 11550, + 11551, 1, 0, 0, 0, 11551, 1015, 1, 0, 0, 0, 11552, 11550, 1, 0, 0, 0, 11553, + 11554, 5, 469, 0, 0, 11554, 11555, 3, 1014, 507, 0, 11555, 1017, 1, 0, + 0, 0, 11556, 11557, 5, 790, 0, 0, 11557, 11558, 5, 255, 0, 0, 11558, 11566, + 5, 460, 0, 0, 11559, 11560, 5, 552, 0, 0, 11560, 11561, 5, 255, 0, 0, 11561, + 11566, 5, 460, 0, 0, 11562, 11563, 5, 1020, 0, 0, 11563, 11564, 5, 971, + 0, 0, 11564, 11566, 5, 727, 0, 0, 11565, 11556, 1, 0, 0, 0, 11565, 11559, + 1, 0, 0, 0, 11565, 11562, 1, 0, 0, 0, 11566, 1019, 1, 0, 0, 0, 11567, 11568, + 5, 554, 0, 0, 11568, 11569, 5, 723, 0, 0, 11569, 11570, 5, 591, 0, 0, 11570, + 11576, 5, 458, 0, 0, 11571, 11572, 5, 23, 0, 0, 11572, 11573, 5, 727, 0, + 0, 11573, 11574, 5, 591, 0, 0, 11574, 11576, 5, 458, 0, 0, 11575, 11567, + 1, 0, 0, 0, 11575, 11571, 1, 0, 0, 0, 11576, 11578, 1, 0, 0, 0, 11577, + 11579, 3, 1018, 509, 0, 11578, 11577, 1, 0, 0, 0, 11578, 11579, 1, 0, 0, + 0, 11579, 1021, 1, 0, 0, 0, 11580, 11581, 7, 87, 0, 0, 11581, 1023, 1, + 0, 0, 0, 11582, 11583, 5, 1068, 0, 0, 11583, 1025, 1, 0, 0, 0, 11584, 11585, + 5, 19, 0, 0, 11585, 11586, 5, 458, 0, 0, 11586, 11598, 5, 802, 0, 0, 11587, + 11588, 5, 588, 0, 0, 11588, 11589, 5, 420, 0, 0, 11589, 11599, 5, 723, + 0, 0, 11590, 11591, 5, 922, 0, 0, 11591, 11592, 5, 505, 0, 0, 11592, 11599, + 5, 723, 0, 0, 11593, 11595, 5, 922, 0, 0, 11594, 11596, 3, 1022, 511, 0, + 11595, 11594, 1, 0, 0, 0, 11595, 11596, 1, 0, 0, 0, 11596, 11597, 1, 0, + 0, 0, 11597, 11599, 3, 1024, 512, 0, 11598, 11587, 1, 0, 0, 0, 11598, 11590, + 1, 0, 0, 0, 11598, 11593, 1, 0, 0, 0, 11599, 1027, 1, 0, 0, 0, 11600, 11601, + 3, 1024, 512, 0, 11601, 11602, 5, 56, 0, 0, 11602, 11610, 3, 886, 443, + 0, 11603, 11604, 5, 1110, 0, 0, 11604, 11605, 3, 1024, 512, 0, 11605, 11606, + 5, 56, 0, 0, 11606, 11607, 3, 886, 443, 0, 11607, 11609, 1, 0, 0, 0, 11608, + 11603, 1, 0, 0, 0, 11609, 11612, 1, 0, 0, 0, 11610, 11608, 1, 0, 0, 0, + 11610, 11611, 1, 0, 0, 0, 11611, 1029, 1, 0, 0, 0, 11612, 11610, 1, 0, + 0, 0, 11613, 11614, 5, 228, 0, 0, 11614, 11615, 3, 1028, 514, 0, 11615, + 1031, 1, 0, 0, 0, 11616, 11617, 5, 462, 0, 0, 11617, 11619, 5, 1104, 0, + 0, 11618, 11620, 3, 1010, 505, 0, 11619, 11618, 1, 0, 0, 0, 11619, 11620, + 1, 0, 0, 0, 11620, 11622, 1, 0, 0, 0, 11621, 11623, 3, 1072, 536, 0, 11622, + 11621, 1, 0, 0, 0, 11622, 11623, 1, 0, 0, 0, 11623, 11625, 1, 0, 0, 0, + 11624, 11626, 3, 1016, 508, 0, 11625, 11624, 1, 0, 0, 0, 11625, 11626, + 1, 0, 0, 0, 11626, 11628, 1, 0, 0, 0, 11627, 11629, 3, 1020, 510, 0, 11628, + 11627, 1, 0, 0, 0, 11628, 11629, 1, 0, 0, 0, 11629, 11631, 1, 0, 0, 0, + 11630, 11632, 3, 1026, 513, 0, 11631, 11630, 1, 0, 0, 0, 11631, 11632, + 1, 0, 0, 0, 11632, 11634, 1, 0, 0, 0, 11633, 11635, 3, 872, 436, 0, 11634, + 11633, 1, 0, 0, 0, 11634, 11635, 1, 0, 0, 0, 11635, 11637, 1, 0, 0, 0, + 11636, 11638, 3, 1030, 515, 0, 11637, 11636, 1, 0, 0, 0, 11637, 11638, + 1, 0, 0, 0, 11638, 11639, 1, 0, 0, 0, 11639, 11640, 5, 1105, 0, 0, 11640, + 1033, 1, 0, 0, 0, 11641, 11642, 5, 604, 0, 0, 11642, 11643, 5, 1104, 0, + 0, 11643, 11644, 3, 856, 428, 0, 11644, 11645, 5, 1104, 0, 0, 11645, 11646, + 3, 856, 428, 0, 11646, 11647, 5, 1105, 0, 0, 11647, 11648, 5, 322, 0, 0, + 11648, 11649, 3, 856, 428, 0, 11649, 11650, 5, 380, 0, 0, 11650, 11651, + 5, 1104, 0, 0, 11651, 11656, 3, 918, 459, 0, 11652, 11653, 5, 1110, 0, + 0, 11653, 11655, 3, 918, 459, 0, 11654, 11652, 1, 0, 0, 0, 11655, 11658, + 1, 0, 0, 0, 11656, 11654, 1, 0, 0, 0, 11656, 11657, 1, 0, 0, 0, 11657, + 11659, 1, 0, 0, 0, 11658, 11656, 1, 0, 0, 0, 11659, 11660, 5, 1105, 0, + 0, 11660, 11661, 5, 1105, 0, 0, 11661, 11674, 1, 0, 0, 0, 11662, 11663, + 5, 972, 0, 0, 11663, 11664, 5, 1104, 0, 0, 11664, 11665, 3, 856, 428, 0, + 11665, 11666, 5, 322, 0, 0, 11666, 11667, 3, 874, 437, 0, 11667, 11668, + 5, 380, 0, 0, 11668, 11669, 5, 1104, 0, 0, 11669, 11670, 3, 876, 438, 0, + 11670, 11671, 5, 1105, 0, 0, 11671, 11672, 5, 1105, 0, 0, 11672, 11674, + 1, 0, 0, 0, 11673, 11641, 1, 0, 0, 0, 11673, 11662, 1, 0, 0, 0, 11674, + 1035, 1, 0, 0, 0, 11675, 11676, 5, 1104, 0, 0, 11676, 11681, 3, 856, 428, + 0, 11677, 11678, 5, 1110, 0, 0, 11678, 11680, 3, 856, 428, 0, 11679, 11677, + 1, 0, 0, 0, 11680, 11683, 1, 0, 0, 0, 11681, 11679, 1, 0, 0, 0, 11681, + 11682, 1, 0, 0, 0, 11682, 11684, 1, 0, 0, 0, 11683, 11681, 1, 0, 0, 0, + 11684, 11685, 5, 1105, 0, 0, 11685, 1037, 1, 0, 0, 0, 11686, 11687, 5, + 1104, 0, 0, 11687, 11688, 3, 882, 441, 0, 11688, 11689, 5, 1105, 0, 0, + 11689, 1039, 1, 0, 0, 0, 11690, 11691, 5, 999, 0, 0, 11691, 11696, 3, 1038, + 519, 0, 11692, 11693, 5, 1110, 0, 0, 11693, 11695, 3, 1038, 519, 0, 11694, + 11692, 1, 0, 0, 0, 11695, 11698, 1, 0, 0, 0, 11696, 11694, 1, 0, 0, 0, + 11696, 11697, 1, 0, 0, 0, 11697, 11700, 1, 0, 0, 0, 11698, 11696, 1, 0, + 0, 0, 11699, 11701, 3, 962, 481, 0, 11700, 11699, 1, 0, 0, 0, 11700, 11701, + 1, 0, 0, 0, 11701, 11703, 1, 0, 0, 0, 11702, 11704, 3, 1036, 518, 0, 11703, + 11702, 1, 0, 0, 0, 11703, 11704, 1, 0, 0, 0, 11704, 1041, 1, 0, 0, 0, 11705, + 11708, 7, 88, 0, 0, 11706, 11708, 7, 89, 0, 0, 11707, 11705, 1, 0, 0, 0, + 11707, 11706, 1, 0, 0, 0, 11708, 1043, 1, 0, 0, 0, 11709, 11710, 7, 90, + 0, 0, 11710, 11711, 5, 1104, 0, 0, 11711, 11712, 3, 880, 440, 0, 11712, + 11713, 5, 1105, 0, 0, 11713, 1045, 1, 0, 0, 0, 11714, 11719, 5, 1104, 0, + 0, 11715, 11720, 3, 880, 440, 0, 11716, 11717, 3, 880, 440, 0, 11717, 11718, + 5, 727, 0, 0, 11718, 11720, 1, 0, 0, 0, 11719, 11715, 1, 0, 0, 0, 11719, + 11716, 1, 0, 0, 0, 11720, 11721, 1, 0, 0, 0, 11721, 11723, 5, 1105, 0, + 0, 11722, 11724, 3, 1044, 522, 0, 11723, 11722, 1, 0, 0, 0, 11723, 11724, + 1, 0, 0, 0, 11724, 1047, 1, 0, 0, 0, 11725, 11727, 7, 91, 0, 0, 11726, + 11728, 3, 1042, 521, 0, 11727, 11726, 1, 0, 0, 0, 11727, 11728, 1, 0, 0, + 0, 11728, 11729, 1, 0, 0, 0, 11729, 11730, 3, 1046, 523, 0, 11730, 1049, + 1, 0, 0, 0, 11731, 11735, 6, 525, -1, 0, 11732, 11734, 5, 511, 0, 0, 11733, + 11732, 1, 0, 0, 0, 11734, 11737, 1, 0, 0, 0, 11735, 11733, 1, 0, 0, 0, + 11735, 11736, 1, 0, 0, 0, 11736, 11743, 1, 0, 0, 0, 11737, 11735, 1, 0, + 0, 0, 11738, 11744, 3, 1058, 529, 0, 11739, 11740, 5, 1104, 0, 0, 11740, + 11741, 3, 1050, 525, 0, 11741, 11742, 5, 1105, 0, 0, 11742, 11744, 1, 0, + 0, 0, 11743, 11738, 1, 0, 0, 0, 11743, 11739, 1, 0, 0, 0, 11744, 11753, + 1, 0, 0, 0, 11745, 11746, 10, 2, 0, 0, 11746, 11747, 5, 40, 0, 0, 11747, + 11752, 3, 1050, 525, 3, 11748, 11749, 10, 1, 0, 0, 11749, 11750, 5, 564, + 0, 0, 11750, 11752, 3, 1050, 525, 2, 11751, 11745, 1, 0, 0, 0, 11751, 11748, + 1, 0, 0, 0, 11752, 11755, 1, 0, 0, 0, 11753, 11751, 1, 0, 0, 0, 11753, + 11754, 1, 0, 0, 0, 11754, 1051, 1, 0, 0, 0, 11755, 11753, 1, 0, 0, 0, 11756, + 11757, 7, 92, 0, 0, 11757, 1053, 1, 0, 0, 0, 11758, 11760, 5, 511, 0, 0, + 11759, 11758, 1, 0, 0, 0, 11759, 11760, 1, 0, 0, 0, 11760, 11761, 1, 0, + 0, 0, 11761, 11762, 5, 522, 0, 0, 11762, 1055, 1, 0, 0, 0, 11763, 11764, + 3, 932, 466, 0, 11764, 1057, 1, 0, 0, 0, 11765, 11766, 5, 285, 0, 0, 11766, + 11767, 5, 1104, 0, 0, 11767, 11768, 3, 1056, 528, 0, 11768, 11769, 5, 1105, + 0, 0, 11769, 11845, 1, 0, 0, 0, 11770, 11771, 3, 886, 443, 0, 11771, 11772, + 3, 1052, 526, 0, 11772, 11773, 3, 886, 443, 0, 11773, 11845, 1, 0, 0, 0, + 11774, 11775, 3, 886, 443, 0, 11775, 11776, 3, 1052, 526, 0, 11776, 11777, + 7, 93, 0, 0, 11777, 11778, 5, 1104, 0, 0, 11778, 11779, 3, 1056, 528, 0, + 11779, 11780, 5, 1105, 0, 0, 11780, 11845, 1, 0, 0, 0, 11781, 11783, 3, + 886, 443, 0, 11782, 11784, 5, 511, 0, 0, 11783, 11782, 1, 0, 0, 0, 11783, + 11784, 1, 0, 0, 0, 11784, 11785, 1, 0, 0, 0, 11785, 11786, 5, 96, 0, 0, + 11786, 11787, 3, 886, 443, 0, 11787, 11788, 5, 40, 0, 0, 11788, 11789, + 3, 886, 443, 0, 11789, 11845, 1, 0, 0, 0, 11790, 11792, 3, 886, 443, 0, + 11791, 11793, 5, 511, 0, 0, 11792, 11791, 1, 0, 0, 0, 11792, 11793, 1, + 0, 0, 0, 11793, 11794, 1, 0, 0, 0, 11794, 11795, 5, 380, 0, 0, 11795, 11798, + 5, 1104, 0, 0, 11796, 11799, 3, 1056, 528, 0, 11797, 11799, 3, 882, 441, + 0, 11798, 11796, 1, 0, 0, 0, 11798, 11797, 1, 0, 0, 0, 11799, 11800, 1, + 0, 0, 0, 11800, 11801, 5, 1105, 0, 0, 11801, 11845, 1, 0, 0, 0, 11802, + 11804, 3, 886, 443, 0, 11803, 11805, 5, 511, 0, 0, 11804, 11803, 1, 0, + 0, 0, 11804, 11805, 1, 0, 0, 0, 11805, 11806, 1, 0, 0, 0, 11806, 11807, + 7, 76, 0, 0, 11807, 11810, 3, 886, 443, 0, 11808, 11809, 5, 278, 0, 0, + 11809, 11811, 3, 886, 443, 0, 11810, 11808, 1, 0, 0, 0, 11810, 11811, 1, + 0, 0, 0, 11811, 11845, 1, 0, 0, 0, 11812, 11814, 3, 886, 443, 0, 11813, + 11815, 5, 511, 0, 0, 11814, 11813, 1, 0, 0, 0, 11814, 11815, 1, 0, 0, 0, + 11815, 11816, 1, 0, 0, 0, 11816, 11817, 5, 717, 0, 0, 11817, 11818, 3, + 886, 443, 0, 11818, 11845, 1, 0, 0, 0, 11819, 11821, 3, 886, 443, 0, 11820, + 11822, 5, 511, 0, 0, 11821, 11820, 1, 0, 0, 0, 11821, 11822, 1, 0, 0, 0, + 11822, 11823, 1, 0, 0, 0, 11823, 11824, 7, 76, 0, 0, 11824, 11825, 5, 43, + 0, 0, 11825, 11826, 5, 1104, 0, 0, 11826, 11831, 3, 886, 443, 0, 11827, + 11828, 5, 1110, 0, 0, 11828, 11830, 3, 886, 443, 0, 11829, 11827, 1, 0, + 0, 0, 11830, 11833, 1, 0, 0, 0, 11831, 11829, 1, 0, 0, 0, 11831, 11832, + 1, 0, 0, 0, 11832, 11834, 1, 0, 0, 0, 11833, 11831, 1, 0, 0, 0, 11834, + 11837, 5, 1105, 0, 0, 11835, 11836, 5, 278, 0, 0, 11836, 11838, 3, 886, + 443, 0, 11837, 11835, 1, 0, 0, 0, 11837, 11838, 1, 0, 0, 0, 11838, 11845, + 1, 0, 0, 0, 11839, 11840, 3, 886, 443, 0, 11840, 11841, 5, 398, 0, 0, 11841, + 11842, 3, 1054, 527, 0, 11842, 11845, 1, 0, 0, 0, 11843, 11845, 3, 886, + 443, 0, 11844, 11765, 1, 0, 0, 0, 11844, 11770, 1, 0, 0, 0, 11844, 11774, + 1, 0, 0, 0, 11844, 11781, 1, 0, 0, 0, 11844, 11790, 1, 0, 0, 0, 11844, + 11802, 1, 0, 0, 0, 11844, 11812, 1, 0, 0, 0, 11844, 11819, 1, 0, 0, 0, + 11844, 11839, 1, 0, 0, 0, 11844, 11843, 1, 0, 0, 0, 11845, 1059, 1, 0, + 0, 0, 11846, 11847, 5, 1019, 0, 0, 11847, 11848, 3, 1050, 525, 0, 11848, + 1061, 1, 0, 0, 0, 11849, 11853, 3, 856, 428, 0, 11850, 11853, 3, 880, 440, + 0, 11851, 11853, 3, 886, 443, 0, 11852, 11849, 1, 0, 0, 0, 11852, 11850, + 1, 0, 0, 0, 11852, 11851, 1, 0, 0, 0, 11853, 1063, 1, 0, 0, 0, 11854, 11855, + 5, 350, 0, 0, 11855, 11856, 5, 110, 0, 0, 11856, 11861, 3, 1062, 531, 0, + 11857, 11858, 5, 1110, 0, 0, 11858, 11860, 3, 1062, 531, 0, 11859, 11857, + 1, 0, 0, 0, 11860, 11863, 1, 0, 0, 0, 11861, 11859, 1, 0, 0, 0, 11861, + 11862, 1, 0, 0, 0, 11862, 11865, 1, 0, 0, 0, 11863, 11861, 1, 0, 0, 0, + 11864, 11866, 3, 1066, 533, 0, 11865, 11864, 1, 0, 0, 0, 11865, 11866, + 1, 0, 0, 0, 11866, 11887, 1, 0, 0, 0, 11867, 11868, 5, 350, 0, 0, 11868, + 11873, 5, 110, 0, 0, 11869, 11874, 5, 196, 0, 0, 11870, 11871, 5, 351, + 0, 0, 11871, 11874, 5, 784, 0, 0, 11872, 11874, 5, 721, 0, 0, 11873, 11869, + 1, 0, 0, 0, 11873, 11870, 1, 0, 0, 0, 11873, 11872, 1, 0, 0, 0, 11874, + 11875, 1, 0, 0, 0, 11875, 11876, 5, 1104, 0, 0, 11876, 11881, 3, 1062, + 531, 0, 11877, 11878, 5, 1110, 0, 0, 11878, 11880, 3, 1062, 531, 0, 11879, + 11877, 1, 0, 0, 0, 11880, 11883, 1, 0, 0, 0, 11881, 11879, 1, 0, 0, 0, + 11881, 11882, 1, 0, 0, 0, 11882, 11884, 1, 0, 0, 0, 11883, 11881, 1, 0, + 0, 0, 11884, 11885, 5, 1105, 0, 0, 11885, 11887, 1, 0, 0, 0, 11886, 11854, + 1, 0, 0, 0, 11886, 11867, 1, 0, 0, 0, 11887, 1065, 1, 0, 0, 0, 11888, 11889, + 5, 355, 0, 0, 11889, 11890, 3, 1050, 525, 0, 11890, 1067, 1, 0, 0, 0, 11891, + 11892, 5, 640, 0, 0, 11892, 11893, 3, 886, 443, 0, 11893, 1069, 1, 0, 0, + 0, 11894, 11898, 3, 856, 428, 0, 11895, 11898, 3, 880, 440, 0, 11896, 11898, + 3, 886, 443, 0, 11897, 11894, 1, 0, 0, 0, 11897, 11895, 1, 0, 0, 0, 11897, + 11896, 1, 0, 0, 0, 11898, 11900, 1, 0, 0, 0, 11899, 11901, 7, 79, 0, 0, + 11900, 11899, 1, 0, 0, 0, 11900, 11901, 1, 0, 0, 0, 11901, 11904, 1, 0, + 0, 0, 11902, 11903, 5, 521, 0, 0, 11903, 11905, 7, 87, 0, 0, 11904, 11902, + 1, 0, 0, 0, 11904, 11905, 1, 0, 0, 0, 11905, 1071, 1, 0, 0, 0, 11906, 11907, + 5, 567, 0, 0, 11907, 11908, 5, 110, 0, 0, 11908, 11913, 3, 1070, 535, 0, + 11909, 11910, 5, 1110, 0, 0, 11910, 11912, 3, 1070, 535, 0, 11911, 11909, + 1, 0, 0, 0, 11912, 11915, 1, 0, 0, 0, 11913, 11911, 1, 0, 0, 0, 11913, + 11914, 1, 0, 0, 0, 11914, 1073, 1, 0, 0, 0, 11915, 11913, 1, 0, 0, 0, 11916, + 11917, 7, 94, 0, 0, 11917, 1075, 1, 0, 0, 0, 11918, 11919, 7, 95, 0, 0, + 11919, 1077, 1, 0, 0, 0, 11920, 11921, 5, 431, 0, 0, 11921, 11924, 3, 880, + 440, 0, 11922, 11923, 5, 544, 0, 0, 11923, 11925, 3, 880, 440, 0, 11924, + 11922, 1, 0, 0, 0, 11924, 11925, 1, 0, 0, 0, 11925, 11945, 1, 0, 0, 0, + 11926, 11927, 5, 544, 0, 0, 11927, 11929, 3, 880, 440, 0, 11928, 11926, + 1, 0, 0, 0, 11928, 11929, 1, 0, 0, 0, 11929, 11931, 1, 0, 0, 0, 11930, + 11932, 3, 1074, 537, 0, 11931, 11930, 1, 0, 0, 0, 11931, 11932, 1, 0, 0, + 0, 11932, 11933, 1, 0, 0, 0, 11933, 11935, 5, 311, 0, 0, 11934, 11936, + 3, 1076, 538, 0, 11935, 11934, 1, 0, 0, 0, 11935, 11936, 1, 0, 0, 0, 11936, + 11937, 1, 0, 0, 0, 11937, 11939, 3, 880, 440, 0, 11938, 11940, 3, 1074, + 537, 0, 11939, 11938, 1, 0, 0, 0, 11939, 11940, 1, 0, 0, 0, 11940, 11942, + 1, 0, 0, 0, 11941, 11943, 5, 556, 0, 0, 11942, 11941, 1, 0, 0, 0, 11942, + 11943, 1, 0, 0, 0, 11943, 11945, 1, 0, 0, 0, 11944, 11920, 1, 0, 0, 0, + 11944, 11928, 1, 0, 0, 0, 11945, 1079, 1, 0, 0, 0, 11946, 11947, 7, 96, + 0, 0, 11947, 1081, 1, 0, 0, 0, 1547, 1087, 1091, 1093, 1105, 1111, 1119, + 1123, 1131, 1135, 1139, 1145, 1154, 1158, 1162, 1166, 1174, 1177, 1186, + 1194, 1209, 1218, 1222, 1229, 1240, 1244, 1251, 1271, 1276, 1280, 1287, + 1296, 1298, 1302, 1313, 1339, 1348, 1351, 1354, 1357, 1362, 1368, 1377, + 1380, 1383, 1386, 1391, 1394, 1406, 1416, 1430, 1445, 1449, 1456, 1464, + 1467, 1470, 1473, 1478, 1481, 1485, 1495, 1503, 1507, 1519, 1524, 1536, + 1541, 1553, 1558, 1560, 1569, 1581, 1584, 1599, 1601, 1611, 1613, 1621, + 1627, 1629, 1636, 1638, 1647, 1653, 1655, 1665, 1670, 1672, 1683, 1685, + 1698, 1700, 1705, 1707, 1717, 1719, 1723, 1729, 1736, 1752, 1768, 1781, + 1783, 1790, 1802, 1809, 1839, 1844, 1851, 1864, 1869, 1887, 1891, 1907, + 1911, 1918, 1921, 1937, 1942, 1947, 1952, 1957, 1960, 1966, 1971, 1973, + 1980, 1982, 1990, 1996, 1998, 2008, 2013, 2015, 2025, 2027, 2039, 2044, + 2046, 2056, 2058, 2062, 2066, 2082, 2091, 2093, 2107, 2111, 2125, 2136, + 2141, 2150, 2153, 2166, 2171, 2213, 2257, 2284, 2342, 2437, 2450, 2458, + 2464, 2476, 2487, 2493, 2497, 2504, 2509, 2514, 2517, 2525, 2533, 2536, + 2540, 2548, 2556, 2560, 2569, 2572, 2583, 2593, 2603, 2610, 2615, 2618, + 2621, 2636, 2645, 2659, 2669, 2693, 2700, 2709, 2722, 2728, 2733, 2739, + 2752, 2765, 2772, 2775, 2781, 2791, 2806, 2818, 2825, 2840, 2848, 2856, + 2863, 2874, 2881, 2884, 2890, 2898, 2904, 2916, 2931, 2943, 2955, 2970, + 2982, 2990, 2996, 3008, 3013, 3019, 3030, 3037, 3041, 3043, 3076, 3089, + 3116, 3121, 3126, 3135, 3142, 3154, 3165, 3171, 3191, 3195, 3198, 3202, + 3211, 3215, 3220, 3224, 3228, 3232, 3237, 3241, 3245, 3253, 3261, 3269, + 3274, 3279, 3282, 3297, 3308, 3317, 3324, 3329, 3331, 3336, 3341, 3351, + 3356, 3365, 3370, 3379, 3384, 3391, 3397, 3408, 3415, 3420, 3426, 3440, + 3446, 3452, 3464, 3479, 3491, 3503, 3518, 3530, 3538, 3544, 3556, 3565, + 3574, 3579, 3597, 3612, 3617, 3620, 3628, 3633, 3635, 3644, 3647, 3649, + 3654, 3664, 3673, 3682, 3690, 3695, 3702, 3715, 3727, 3733, 3738, 3748, + 3758, 3765, 3770, 3773, 3776, 3781, 3789, 3797, 3806, 3812, 3819, 3826, + 3836, 3840, 3844, 3847, 3850, 3855, 3864, 3870, 3874, 3883, 3888, 3893, + 3898, 3907, 3909, 3914, 3919, 3928, 3930, 3935, 3940, 3948, 3956, 3964, + 3969, 3974, 3978, 3982, 3991, 3996, 4004, 4010, 4020, 4024, 4028, 4035, + 4038, 4043, 4048, 4057, 4059, 4064, 4069, 4078, 4080, 4085, 4090, 4098, + 4106, 4114, 4121, 4129, 4133, 4142, 4147, 4155, 4161, 4167, 4171, 4178, + 4181, 4186, 4191, 4196, 4201, 4206, 4211, 4216, 4221, 4226, 4231, 4236, + 4241, 4246, 4250, 4254, 4262, 4270, 4276, 4280, 4284, 4291, 4296, 4299, + 4303, 4307, 4316, 4321, 4329, 4335, 4342, 4352, 4356, 4360, 4363, 4366, + 4371, 4380, 4386, 4400, 4403, 4409, 4416, 4421, 4424, 4430, 4437, 4442, + 4453, 4459, 4464, 4475, 4481, 4486, 4497, 4500, 4503, 4508, 4521, 4527, + 4532, 4542, 4555, 4560, 4563, 4571, 4578, 4583, 4586, 4594, 4597, 4599, + 4603, 4607, 4612, 4615, 4623, 4631, 4634, 4638, 4642, 4649, 4657, 4661, + 4667, 4672, 4677, 4680, 4685, 4698, 4704, 4709, 4719, 4729, 4735, 4740, + 4748, 4756, 4761, 4769, 4774, 4779, 4784, 4787, 4790, 4795, 4803, 4811, + 4821, 4826, 4840, 4852, 4872, 4881, 4893, 4897, 4905, 4909, 4927, 4929, + 4932, 4935, 4938, 4950, 4952, 4962, 4965, 4972, 4982, 4986, 4993, 4997, + 5002, 5005, 5010, 5016, 5022, 5038, 5041, 5056, 5065, 5070, 5073, 5076, + 5080, 5087, 5095, 5097, 5100, 5103, 5107, 5123, 5134, 5142, 5146, 5163, + 5166, 5184, 5188, 5191, 5204, 5208, 5210, 5221, 5224, 5235, 5238, 5240, + 5246, 5259, 5278, 5281, 5302, 5314, 5317, 5324, 5328, 5342, 5349, 5353, + 5356, 5362, 5365, 5381, 5389, 5402, 5409, 5414, 5419, 5424, 5429, 5432, + 5435, 5440, 5445, 5448, 5451, 5454, 5457, 5460, 5463, 5468, 5476, 5484, + 5494, 5501, 5506, 5514, 5524, 5533, 5554, 5562, 5570, 5584, 5596, 5616, + 5630, 5644, 5647, 5654, 5666, 5679, 5686, 5705, 5709, 5724, 5730, 5737, + 5743, 5771, 5779, 5782, 5790, 5800, 5818, 5832, 5836, 5843, 5849, 5852, + 5862, 5870, 5873, 5876, 5887, 5890, 5895, 5897, 5900, 5923, 5926, 5930, + 5933, 5936, 5942, 5957, 5964, 5980, 5990, 6034, 6048, 6053, 6061, 6069, + 6074, 6077, 6081, 6085, 6107, 6113, 6118, 6130, 6143, 6149, 6153, 6158, + 6173, 6186, 6192, 6217, 6223, 6225, 6229, 6233, 6249, 6253, 6257, 6265, + 6268, 6274, 6279, 6283, 6294, 6296, 6300, 6303, 6307, 6311, 6316, 6321, + 6324, 6327, 6330, 6334, 6343, 6364, 6368, 6384, 6387, 6401, 6404, 6410, + 6422, 6424, 6427, 6430, 6443, 6448, 6458, 6463, 6468, 6471, 6476, 6481, + 6488, 6493, 6500, 6503, 6506, 6514, 6519, 6522, 6528, 6531, 6534, 6537, + 6540, 6544, 6549, 6556, 6559, 6562, 6572, 6575, 6578, 6581, 6585, 6590, + 6597, 6600, 6603, 6615, 6618, 6621, 6624, 6627, 6629, 6636, 6639, 6646, + 6657, 6663, 6673, 6683, 6686, 6695, 6698, 6707, 6710, 6719, 6725, 6730, + 6736, 6748, 6754, 6759, 6765, 6770, 6774, 6784, 6788, 6791, 6801, 6804, + 6816, 6819, 6822, 6825, 6839, 6842, 6845, 6852, 6855, 6865, 6868, 6880, + 6883, 6886, 6889, 6901, 6904, 6907, 6910, 6915, 6934, 6938, 6943, 6954, + 6962, 6974, 6977, 6982, 6986, 6989, 6992, 6995, 6998, 7001, 7008, 7017, + 7024, 7027, 7030, 7048, 7076, 7080, 7085, 7096, 7100, 7105, 7119, 7121, + 7125, 7129, 7135, 7140, 7145, 7150, 7153, 7166, 7170, 7180, 7183, 7195, + 7198, 7201, 7205, 7219, 7222, 7225, 7228, 7235, 7238, 7248, 7251, 7258, + 7272, 7275, 7278, 7281, 7286, 7292, 7302, 7312, 7315, 7324, 7327, 7336, + 7339, 7348, 7354, 7359, 7365, 7377, 7381, 7388, 7391, 7397, 7399, 7404, + 7407, 7413, 7415, 7419, 7423, 7427, 7441, 7446, 7451, 7455, 7461, 7471, + 7480, 7484, 7487, 7491, 7495, 7500, 7505, 7510, 7513, 7516, 7519, 7523, + 7528, 7550, 7558, 7567, 7569, 7577, 7585, 7590, 7595, 7603, 7608, 7613, + 7619, 7624, 7637, 7642, 7647, 7652, 7660, 7663, 7667, 7672, 7685, 7690, + 7695, 7700, 7708, 7716, 7721, 7726, 7729, 7734, 7739, 7742, 7744, 7748, + 7753, 7774, 7779, 7784, 7789, 7794, 7799, 7804, 7809, 7814, 7818, 7823, + 7836, 7841, 7844, 7854, 7857, 7863, 7866, 7872, 7876, 7880, 7883, 7886, + 7889, 7893, 7898, 7904, 7909, 7912, 7916, 7921, 7932, 7938, 7953, 7959, + 7965, 7975, 7982, 7992, 8016, 8067, 8076, 8101, 8111, 8129, 8133, 8137, + 8139, 8142, 8144, 8176, 8179, 8183, 8186, 8194, 8200, 8205, 8210, 8212, + 8214, 8228, 8231, 8238, 8243, 8248, 8251, 8253, 8278, 8287, 8290, 8299, + 8302, 8305, 8314, 8317, 8320, 8324, 8328, 8331, 8335, 8339, 8342, 8356, + 8359, 8362, 8370, 8373, 8376, 8380, 8383, 8387, 8392, 8406, 8409, 8412, + 8420, 8423, 8426, 8428, 8439, 8450, 8458, 8463, 8471, 8476, 8497, 8500, + 8531, 8537, 8541, 8545, 8551, 8554, 8557, 8560, 8564, 8568, 8572, 8579, + 8582, 8585, 8589, 8593, 8597, 8603, 8607, 8611, 8615, 8621, 8624, 8627, + 8630, 8632, 8637, 8641, 8644, 8647, 8656, 8662, 8675, 8689, 8696, 8718, + 8720, 8727, 8731, 8736, 8739, 8742, 8747, 8749, 8752, 8759, 8761, 8765, + 8768, 8772, 8776, 8783, 8788, 8791, 8795, 8800, 8802, 8808, 8811, 8819, + 8824, 8829, 8832, 8835, 8838, 8841, 8844, 8847, 8851, 8854, 8858, 8863, + 8865, 8871, 8874, 8877, 8880, 8883, 8886, 8893, 8897, 8901, 8905, 8909, + 8918, 8921, 8923, 8932, 8940, 8949, 8953, 8962, 8967, 8972, 8975, 8980, + 8985, 8990, 8993, 8996, 9004, 9007, 9011, 9019, 9025, 9031, 9035, 9039, + 9042, 9045, 9053, 9056, 9059, 9063, 9070, 9075, 9079, 9082, 9085, 9088, + 9095, 9099, 9103, 9108, 9110, 9115, 9135, 9153, 9165, 9167, 9202, 9238, + 9245, 9254, 9261, 9265, 9271, 9279, 9283, 9289, 9297, 9304, 9311, 9315, + 9333, 9341, 9348, 9355, 9364, 9376, 9385, 9392, 9396, 9401, 9405, 9411, + 9422, 9429, 9436, 9440, 9445, 9452, 9459, 9466, 9473, 9481, 9490, 9518, + 9530, 9535, 9594, 9611, 9618, 9632, 9667, 9712, 9785, 9789, 9793, 9799, + 9803, 9805, 9807, 9810, 9813, 9818, 9824, 9828, 9832, 9837, 9840, 9842, + 9847, 9857, 9861, 9865, 9868, 9871, 9874, 9906, 9912, 9918, 9924, 9927, + 9930, 9932, 9934, 9937, 9940, 9944, 9949, 9955, 9958, 9961, 9963, 9965, + 9968, 9971, 9979, 9985, 9996, 9998, 10003, 10014, 10016, 10022, 10027, + 10041, 10056, 10064, 10068, 10072, 10078, 10084, 10090, 10093, 10104, 10110, + 10114, 10119, 10125, 10128, 10137, 10140, 10146, 10153, 10160, 10164, 10168, + 10170, 10175, 10178, 10182, 10187, 10192, 10195, 10200, 10206, 10212, 10220, + 10228, 10234, 10239, 10246, 10249, 10253, 10257, 10260, 10266, 10268, 10270, + 10273, 10276, 10281, 10284, 10293, 10312, 10315, 10320, 10323, 10328, 10331, + 10336, 10347, 10351, 10355, 10361, 10364, 10367, 10369, 10371, 10374, 10377, + 10383, 10389, 10392, 10396, 10400, 10405, 10409, 10413, 10418, 10422, 10426, + 10432, 10435, 10438, 10440, 10442, 10445, 10448, 10453, 10465, 10479, 10486, + 10508, 10523, 10540, 10547, 10552, 10565, 10579, 10588, 10593, 10598, 10602, + 10641, 10662, 10682, 10707, 10713, 10719, 10725, 10729, 10739, 10745, 10747, + 10749, 10768, 10786, 10793, 10807, 10814, 10827, 10831, 10838, 10848, 10855, + 10862, 10869, 10876, 10883, 10893, 10903, 10909, 10921, 10930, 10937, 10961, + 10973, 10978, 10991, 10996, 11005, 11007, 11011, 11015, 11021, 11026, 11030, + 11034, 11039, 11043, 11048, 11053, 11063, 11070, 11074, 11082, 11086, 11090, + 11103, 11109, 11118, 11122, 11129, 11144, 11151, 11160, 11165, 11169, 11173, + 11180, 11183, 11186, 11189, 11192, 11195, 11198, 11207, 11212, 11222, 11227, + 11233, 11240, 11244, 11250, 11255, 11257, 11260, 11266, 11269, 11296, 11305, + 11314, 11317, 11321, 11324, 11327, 11330, 11333, 11336, 11345, 11355, 11358, + 11361, 11367, 11370, 11376, 11379, 11384, 11386, 11400, 11406, 11413, 11423, + 11427, 11432, 11438, 11442, 11445, 11451, 11458, 11460, 11464, 11471, 11487, + 11498, 11513, 11523, 11528, 11538, 11544, 11550, 11565, 11575, 11578, 11595, + 11598, 11610, 11619, 11622, 11625, 11628, 11631, 11634, 11637, 11656, 11673, + 11681, 11696, 11700, 11703, 11707, 11719, 11723, 11727, 11735, 11743, 11751, + 11753, 11759, 11783, 11792, 11798, 11804, 11810, 11814, 11821, 11831, 11837, + 11844, 11852, 11861, 11865, 11873, 11881, 11886, 11897, 11900, 11904, 11913, + 11924, 11928, 11931, 11935, 11939, 11942, 11944, + } + 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) + } +} + +// SnowflakeParserInit initializes any static state used to implement SnowflakeParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewSnowflakeParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func SnowflakeParserInit() { + staticData := &SnowflakeParserParserStaticData + staticData.once.Do(snowflakeparserParserInit) +} + +// NewSnowflakeParser produces a new parser instance for the optional input antlr.TokenStream. +func NewSnowflakeParser(input antlr.TokenStream) *SnowflakeParser { + SnowflakeParserInit() + this := new(SnowflakeParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &SnowflakeParserParserStaticData + 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 = "SnowflakeParser.g4" + + return this +} + +// SnowflakeParser tokens. +const ( + SnowflakeParserEOF = antlr.TokenEOF + SnowflakeParserAAD_PROVISIONER_Q = 1 + SnowflakeParserABORT = 2 + SnowflakeParserABORT_AFTER_WAIT = 3 + SnowflakeParserABORT_DETACHED_QUERY = 4 + SnowflakeParserABORT_STATEMENT = 5 + SnowflakeParserABSENT = 6 + SnowflakeParserABSOLUTE = 7 + SnowflakeParserACCESS = 8 + SnowflakeParserACCOUNT = 9 + SnowflakeParserACCOUNTADMIN = 10 + SnowflakeParserACCOUNTS = 11 + SnowflakeParserACTION = 12 + SnowflakeParserACTIVE = 13 + SnowflakeParserADD = 14 + SnowflakeParserADMINISTER = 15 + SnowflakeParserADMIN_NAME = 16 + SnowflakeParserADMIN_PASSWORD = 17 + SnowflakeParserAES = 18 + SnowflakeParserAFTER = 19 + SnowflakeParserAGGREGATE = 20 + SnowflakeParserALERT = 21 + SnowflakeParserALERTS = 22 + SnowflakeParserALL = 23 + SnowflakeParserALLOWED = 24 + SnowflakeParserALLOWED_ACCOUNTS = 25 + SnowflakeParserALLOWED_DATABASES = 26 + SnowflakeParserALLOWED_INTEGRATION_TYPES = 27 + SnowflakeParserALLOWED_IP_LIST = 28 + SnowflakeParserALLOWED_SHARES = 29 + SnowflakeParserALLOWED_VALUES = 30 + SnowflakeParserALLOW_CLIENT_MFA_CACHING = 31 + SnowflakeParserALLOW_CONNECTIONS = 32 + SnowflakeParserALLOW_DUPLICATE = 33 + SnowflakeParserALLOW_ID_TOKEN = 34 + SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS = 35 + SnowflakeParserALLOW_OVERLAPPING_EXECUTION = 36 + SnowflakeParserALLOW_SINGLE_EVENT_LOSS = 37 + SnowflakeParserALTER = 38 + SnowflakeParserALWAYS = 39 + SnowflakeParserAND = 40 + SnowflakeParserANONYMOUS = 41 + SnowflakeParserANSI_DEFAULTS = 42 + SnowflakeParserANY = 43 + SnowflakeParserAPI = 44 + SnowflakeParserAPI_ALLOWED_PREFIXES = 45 + SnowflakeParserAPI_AWS_ROLE_ARN = 46 + SnowflakeParserAPI_BLOCKED_PREFIXES = 47 + SnowflakeParserAPI_INTEGRATION = 48 + SnowflakeParserAPI_KEY = 49 + SnowflakeParserAPI_PROVIDER = 50 + SnowflakeParserAPPEND = 51 + SnowflakeParserAPPEND_ONLY = 52 + SnowflakeParserAPPLICATION = 53 + SnowflakeParserAPPLY = 54 + SnowflakeParserAPP_NAME = 55 + SnowflakeParserAS = 56 + SnowflakeParserASC = 57 + SnowflakeParserATTACH = 58 + SnowflakeParserAT_KEYWORD = 59 + SnowflakeParserAUTHORIZATION = 60 + SnowflakeParserAUTHORIZATIONS = 61 + SnowflakeParserAUTO = 62 + SnowflakeParserAUTO_Q = 63 + SnowflakeParserAUTOCOMMIT = 64 + SnowflakeParserAUTOCOMMIT_API_SUPPORTED = 65 + SnowflakeParserAUTOINCREMENT = 66 + SnowflakeParserAUTO_COMPRESS = 67 + SnowflakeParserAUTO_DETECT = 68 + SnowflakeParserAUTO_INGEST = 69 + SnowflakeParserAUTO_REFRESH = 70 + SnowflakeParserAUTO_RESUME = 71 + SnowflakeParserAUTO_SUSPEND = 72 + SnowflakeParserAVG = 73 + SnowflakeParserAVRO = 74 + SnowflakeParserAVRO_Q = 75 + SnowflakeParserAWS_KEY_ID = 76 + SnowflakeParserAWS_ROLE = 77 + SnowflakeParserAWS_SECRET_KEY = 78 + SnowflakeParserAWS_SNS = 79 + SnowflakeParserAWS_SNS_ROLE_ARN = 80 + SnowflakeParserAWS_SNS_TOPIC = 81 + SnowflakeParserAWS_SNS_TOPIC_ARN = 82 + SnowflakeParserAWS_TOKEN = 83 + SnowflakeParserAZURE = 84 + SnowflakeParserAZURE_AD_APPLICATION_ID = 85 + SnowflakeParserAZURE_EVENT_GRID = 86 + SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT = 87 + SnowflakeParserAZURE_Q = 88 + SnowflakeParserAZURE_SAS_TOKEN = 89 + SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI = 90 + SnowflakeParserAZURE_TENANT_ID = 91 + SnowflakeParserBASE64 = 92 + SnowflakeParserBEFORE = 93 + SnowflakeParserBEGIN = 94 + SnowflakeParserBERNOULLI = 95 + SnowflakeParserBETWEEN = 96 + SnowflakeParserBINARY_AS_TEXT = 97 + SnowflakeParserBINARY_CHECKSUM = 98 + SnowflakeParserBINARY_FORMAT = 99 + SnowflakeParserBINARY_INPUT_FORMAT = 100 + SnowflakeParserBINARY_OUTPUT_FORMAT = 101 + SnowflakeParserBINDING = 102 + SnowflakeParserBLOCK = 103 + SnowflakeParserBLOCKED_IP_LIST = 104 + SnowflakeParserBLOCKED_ROLES_LIST = 105 + SnowflakeParserBODY = 106 + SnowflakeParserBOTH_Q = 107 + SnowflakeParserBROTLI = 108 + SnowflakeParserBUSINESS_CRITICAL = 109 + SnowflakeParserBY = 110 + SnowflakeParserBZ2 = 111 + SnowflakeParserCACHE = 112 + SnowflakeParserCALL = 113 + SnowflakeParserCALLED = 114 + SnowflakeParserCALLER = 115 + SnowflakeParserCASCADE = 116 + SnowflakeParserCASE = 117 + SnowflakeParserCASE_INSENSITIVE = 118 + SnowflakeParserCASE_SENSITIVE = 119 + SnowflakeParserCAST = 120 + SnowflakeParserCATCH = 121 + SnowflakeParserCERTIFICATE = 122 + SnowflakeParserCHANGE = 123 + SnowflakeParserCHANGES = 124 + SnowflakeParserCHANGETABLE = 125 + SnowflakeParserCHANGE_RETENTION = 126 + SnowflakeParserCHANGE_TRACKING = 127 + SnowflakeParserCHAR = 128 + SnowflakeParserCHARACTER = 129 + SnowflakeParserCHARINDEX = 130 + SnowflakeParserCHECK = 131 + SnowflakeParserCHECKSUM = 132 + SnowflakeParserCHECKSUM_AGG = 133 + SnowflakeParserCHECK_EXPIRATION = 134 + SnowflakeParserCHECK_POLICY = 135 + SnowflakeParserCLASSIFIER_FUNCTION = 136 + SnowflakeParserCLEANUP = 137 + SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS = 138 + SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE = 139 + SnowflakeParserCLIENT_MEMORY_LIMIT = 140 + SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX = 141 + SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE = 142 + SnowflakeParserCLIENT_PREFETCH_THREADS = 143 + SnowflakeParserCLIENT_RESULT_CHUNK_SIZE = 144 + SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE = 145 + SnowflakeParserCLIENT_SESSION_KEEP_ALIVE = 146 + SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY = 147 + SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING = 148 + SnowflakeParserCLONE = 149 + SnowflakeParserCLOSE = 150 + SnowflakeParserCLUSTER = 151 + SnowflakeParserCLUSTERED = 152 + SnowflakeParserCLUSTERING = 153 + SnowflakeParserCOALESCE = 154 + SnowflakeParserCOLLATE = 155 + SnowflakeParserCOLLECTION = 156 + SnowflakeParserCOLUMN = 157 + SnowflakeParserCOLUMNS = 158 + SnowflakeParserCOL_LENGTH = 159 + SnowflakeParserCOL_NAME = 160 + SnowflakeParserCOMMENT = 161 + SnowflakeParserCOMMIT = 162 + SnowflakeParserCOMMITTED = 163 + SnowflakeParserCOMPRESS = 164 + SnowflakeParserCOMPRESSION = 165 + SnowflakeParserCONCAT = 166 + SnowflakeParserCONCAT_NULL_YIELDS_NULL = 167 + SnowflakeParserCONCAT_WS = 168 + SnowflakeParserCONDITION = 169 + SnowflakeParserCONFIGURATION = 170 + SnowflakeParserCONNECT = 171 + SnowflakeParserCONNECTION = 172 + SnowflakeParserCONNECTIONS = 173 + SnowflakeParserCONSTRAINT = 174 + SnowflakeParserCONTAINMENT = 175 + SnowflakeParserCONTAINS = 176 + SnowflakeParserCONTENT = 177 + SnowflakeParserCONTEXT = 178 + SnowflakeParserCONTEXT_HEADERS = 179 + SnowflakeParserCONTEXT_INFO = 180 + SnowflakeParserCONTINUE = 181 + SnowflakeParserCONTROL = 182 + SnowflakeParserCONVERSATION = 183 + SnowflakeParserCOOKIE = 184 + SnowflakeParserCOPY = 185 + SnowflakeParserCOPY_ONLY = 186 + SnowflakeParserCOPY_OPTIONS_ = 187 + SnowflakeParserCOUNT = 188 + SnowflakeParserCOUNT_BIG = 189 + SnowflakeParserCREATE = 190 + SnowflakeParserCREDENTIALS = 191 + SnowflakeParserCREDIT_QUOTA = 192 + SnowflakeParserCROSS = 193 + SnowflakeParserCSV = 194 + SnowflakeParserCSV_Q = 195 + SnowflakeParserCUBE = 196 + SnowflakeParserCUME_DIST = 197 + SnowflakeParserCURRENT = 198 + SnowflakeParserCURRENT_DATE = 199 + SnowflakeParserCURRENT_TIME = 200 + SnowflakeParserCURRENT_TIMESTAMP = 201 + SnowflakeParserCURRENT_USER = 202 + SnowflakeParserCURSOR = 203 + SnowflakeParserCUSTOM = 204 + SnowflakeParserDAILY = 205 + SnowflakeParserDATA = 206 + SnowflakeParserDATABASE = 207 + SnowflakeParserDATABASES = 208 + SnowflakeParserDATA_RETENTION_TIME_IN_DAYS = 209 + SnowflakeParserDATEADD = 210 + SnowflakeParserDATEDIFF = 211 + SnowflakeParserDATENAME = 212 + SnowflakeParserDATEPART = 213 + SnowflakeParserDATE_FORMAT = 214 + SnowflakeParserDATE_INPUT_FORMAT = 215 + SnowflakeParserDATE_OUTPUT_FORMAT = 216 + SnowflakeParserDATE_PART = 217 + SnowflakeParserDAYS = 218 + SnowflakeParserDAYS_TO_EXPIRY = 219 + SnowflakeParserDECLARE = 220 + SnowflakeParserDEFAULT = 221 + SnowflakeParserDEFAULT_DDL_COLLATION_ = 222 + SnowflakeParserDEFAULT_NAMESPACE = 223 + SnowflakeParserDEFAULT_ROLE = 224 + SnowflakeParserDEFAULT_WAREHOUSE = 225 + SnowflakeParserDEFERRABLE = 226 + SnowflakeParserDEFERRED = 227 + SnowflakeParserDEFINE = 228 + SnowflakeParserDEFINITION = 229 + SnowflakeParserDEFLATE = 230 + SnowflakeParserDELEGATED = 231 + SnowflakeParserDELETE = 232 + SnowflakeParserDELTA = 233 + SnowflakeParserDENSE_RANK = 234 + SnowflakeParserDESC = 235 + SnowflakeParserDESCRIBE = 236 + SnowflakeParserDIRECTION = 237 + SnowflakeParserDIRECTORY = 238 + SnowflakeParserDISABLE = 239 + SnowflakeParserDISABLED = 240 + SnowflakeParserDISABLE_AUTO_CONVERT = 241 + SnowflakeParserDISABLE_SNOWFLAKE_DATA = 242 + SnowflakeParserDISK = 243 + SnowflakeParserDISPLAY_NAME = 244 + SnowflakeParserDISTINCT = 245 + SnowflakeParserDO = 246 + SnowflakeParserDOWNSTREAM = 247 + SnowflakeParserDOUBLE = 248 + SnowflakeParserDROP = 249 + SnowflakeParserDYNAMIC = 250 + SnowflakeParserECONOMY = 251 + SnowflakeParserEDITION = 252 + SnowflakeParserELSE = 253 + SnowflakeParserEMAIL = 254 + SnowflakeParserEMPTY_ = 255 + SnowflakeParserEMPTY_FIELD_AS_NULL = 256 + SnowflakeParserENABLE = 257 + SnowflakeParserENABLED = 258 + SnowflakeParserENABLE_FOR_PRIVILEGE = 259 + SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK = 260 + SnowflakeParserENABLE_OCTAL = 261 + SnowflakeParserENABLE_QUERY_ACCELERATION = 262 + SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION = 263 + SnowflakeParserENCODING = 264 + SnowflakeParserENCRYPTION = 265 + SnowflakeParserEND = 266 + SnowflakeParserENDPOINT = 267 + SnowflakeParserEND_TIMESTAMP = 268 + SnowflakeParserENFORCED = 269 + SnowflakeParserENFORCE_LENGTH = 270 + SnowflakeParserENFORCE_SESSION_POLICY = 271 + SnowflakeParserENTERPRISE = 272 + SnowflakeParserEQUALITY = 273 + SnowflakeParserERROR_INTEGRATION = 274 + SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH = 275 + SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE = 276 + SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE = 277 + SnowflakeParserESCAPE = 278 + SnowflakeParserESCAPE_UNENCLOSED_FIELD = 279 + SnowflakeParserEXCEPT = 280 + SnowflakeParserEXCHANGE = 281 + SnowflakeParserEXECUTE = 282 + SnowflakeParserEXECUTION = 283 + SnowflakeParserEXIST = 284 + SnowflakeParserEXISTS = 285 + SnowflakeParserEXIT = 286 + SnowflakeParserEXPAND = 287 + SnowflakeParserEXPIRY_DATE = 288 + SnowflakeParserEXPLAIN = 289 + SnowflakeParserEXPLICIT = 290 + SnowflakeParserEXTERNAL = 291 + SnowflakeParserEXTERNAL_OAUTH = 292 + SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST = 293 + SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST = 294 + SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE = 295 + SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST = 296 + SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST = 297 + SnowflakeParserEXTERNAL_OAUTH_ISSUER = 298 + SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL = 299 + SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY = 300 + SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2 = 301 + SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER = 302 + SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE = 303 + SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM = 304 + SnowflakeParserEXTERNAL_OAUTH_TYPE = 305 + SnowflakeParserEXTERNAL_STAGE = 306 + SnowflakeParserFAILOVER = 307 + SnowflakeParserFAILOVER_MODE = 308 + SnowflakeParserFAIL_OPERATION = 309 + SnowflakeParserFALSE = 310 + SnowflakeParserFETCH = 311 + SnowflakeParserFIELD_DELIMITER = 312 + SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY = 313 + SnowflakeParserFILE = 314 + SnowflakeParserFILES = 315 + SnowflakeParserFILE_EXTENSION = 316 + SnowflakeParserFILE_FORMAT = 317 + SnowflakeParserFILTER = 318 + SnowflakeParserFIRST = 319 + SnowflakeParserFIRST_NAME = 320 + SnowflakeParserFLATTEN = 321 + SnowflakeParserFOR = 322 + SnowflakeParserFORCE = 323 + SnowflakeParserFOREIGN = 324 + SnowflakeParserFORMAT = 325 + SnowflakeParserFORMATS = 326 + SnowflakeParserFORMAT_NAME = 327 + SnowflakeParserFREQUENCY = 328 + SnowflakeParserFROM = 329 + SnowflakeParserFULL = 330 + SnowflakeParserFUNCTION = 331 + SnowflakeParserFUNCTIONS = 332 + SnowflakeParserFUTURE = 333 + SnowflakeParserGCP_PUBSUB = 334 + SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME = 335 + SnowflakeParserGCP_PUBSUB_TOPIC_NAME = 336 + SnowflakeParserGCS = 337 + SnowflakeParserGENERIC_Q = 338 + SnowflakeParserGENERIC_SCIM_PROVISIONER_Q = 339 + SnowflakeParserGEO = 340 + SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT = 341 + SnowflakeParserGEOMETRY_OUTPUT_FORMAT = 342 + SnowflakeParserGET = 343 + SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT = 344 + SnowflakeParserGLOBAL = 345 + SnowflakeParserGOOGLE_AUDIENCE = 346 + SnowflakeParserGOTO = 347 + SnowflakeParserGRANT = 348 + SnowflakeParserGRANTS = 349 + SnowflakeParserGROUP = 350 + SnowflakeParserGROUPING = 351 + SnowflakeParserGROUPING_ID = 352 + SnowflakeParserGROUPS = 353 + SnowflakeParserGZIP = 354 + SnowflakeParserHAVING = 355 + SnowflakeParserHEADER = 356 + SnowflakeParserHEADERS = 357 + SnowflakeParserHEX = 358 + SnowflakeParserHIERARCHYID = 359 + SnowflakeParserHIGH = 360 + SnowflakeParserHISTORY = 361 + SnowflakeParserHOURS = 362 + SnowflakeParserIDENTITY = 363 + SnowflakeParserIF = 364 + SnowflakeParserIFF = 365 + SnowflakeParserIFNULL = 366 + SnowflakeParserIGNORE = 367 + SnowflakeParserIGNORE_CONSTRAINTS = 368 + SnowflakeParserIGNORE_DUP_KEY = 369 + SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX = 370 + SnowflakeParserIGNORE_TRIGGERS = 371 + SnowflakeParserIGNORE_UTF8_ERRORS = 372 + SnowflakeParserILIKE = 373 + SnowflakeParserIMMEDIATE = 374 + SnowflakeParserIMMEDIATELY = 375 + SnowflakeParserIMMUTABLE = 376 + SnowflakeParserIMPLICIT = 377 + SnowflakeParserIMPORT = 378 + SnowflakeParserIMPORTED = 379 + SnowflakeParserIN = 380 + SnowflakeParserINCREMENT = 381 + SnowflakeParserINDEX = 382 + SnowflakeParserINFORMATION = 383 + SnowflakeParserINIT = 384 + SnowflakeParserINITIALLY = 385 + SnowflakeParserINITIALLY_SUSPENDED = 386 + SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB = 387 + SnowflakeParserINNER = 388 + SnowflakeParserINPUT = 389 + SnowflakeParserINSERT = 390 + SnowflakeParserINSERT_ONLY = 391 + SnowflakeParserINSTEAD = 392 + SnowflakeParserINT = 393 + SnowflakeParserINTEGRATION = 394 + SnowflakeParserINTEGRATIONS = 395 + SnowflakeParserINTERSECT = 396 + SnowflakeParserINTO = 397 + SnowflakeParserIS = 398 + SnowflakeParserISNULL = 399 + SnowflakeParserISNUMERIC = 400 + SnowflakeParserISOLATION = 401 + SnowflakeParserJAVASCRIPT = 402 + SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT = 403 + SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC = 404 + SnowflakeParserJDBC_USE_SESSION_TIMEZONE = 405 + SnowflakeParserJOIN = 406 + SnowflakeParserJSON = 407 + SnowflakeParserJSON_Q = 408 + SnowflakeParserJSON_INDENT = 409 + SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT = 410 + SnowflakeParserKB = 411 + SnowflakeParserKEEP = 412 + SnowflakeParserKEY = 413 + SnowflakeParserKEYS = 414 + SnowflakeParserKEYSET = 415 + SnowflakeParserKMS_KEY_ID = 416 + SnowflakeParserLAG = 417 + SnowflakeParserLANGUAGE = 418 + SnowflakeParserLARGE = 419 + SnowflakeParserLAST = 420 + SnowflakeParserLAST_NAME = 421 + SnowflakeParserLAST_QUERY_ID = 422 + SnowflakeParserLAST_VALUE = 423 + SnowflakeParserLATERAL = 424 + SnowflakeParserLEAD = 425 + SnowflakeParserLEFT = 426 + SnowflakeParserLEN = 427 + SnowflakeParserLENGTH = 428 + SnowflakeParserLEVEL = 429 + SnowflakeParserLIKE = 430 + SnowflakeParserLIMIT = 431 + SnowflakeParserLINENO = 432 + SnowflakeParserLIST = 433 + SnowflakeParserLISTENER_IP = 434 + SnowflakeParserLISTENER_PORT = 435 + SnowflakeParserLISTING = 436 + SnowflakeParserLOAD = 437 + SnowflakeParserLOCAL = 438 + SnowflakeParserLOCAL_SERVICE_NAME = 439 + SnowflakeParserLOCATION = 440 + SnowflakeParserLOCKS = 441 + SnowflakeParserLOCK_TIMEOUT = 442 + SnowflakeParserLOG = 443 + SnowflakeParserLOGIN = 444 + SnowflakeParserLOGIN_NAME = 445 + SnowflakeParserLOOKER = 446 + SnowflakeParserLOW = 447 + SnowflakeParserLOWER = 448 + SnowflakeParserLTRIM = 449 + SnowflakeParserLZO = 450 + SnowflakeParserMANAGE = 451 + SnowflakeParserMANAGED = 452 + SnowflakeParserMASK = 453 + SnowflakeParserMASKED = 454 + SnowflakeParserMASKING = 455 + SnowflakeParserMASTER = 456 + SnowflakeParserMASTER_KEY = 457 + SnowflakeParserMATCH = 458 + SnowflakeParserMATCHED = 459 + SnowflakeParserMATCHES = 460 + SnowflakeParserMATCH_BY_COLUMN_NAME = 461 + SnowflakeParserMATCH_RECOGNIZE = 462 + SnowflakeParserMATERIALIZED = 463 + SnowflakeParserMAX_BATCH_ROWS = 464 + SnowflakeParserMAX_CLUSTER_COUNT = 465 + SnowflakeParserMAX_CONCURRENCY_LEVEL = 466 + SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS = 467 + SnowflakeParserMAX_SIZE = 468 + SnowflakeParserMEASURES = 469 + SnowflakeParserMEDIUM = 470 + SnowflakeParserMEMOIZABLE = 471 + SnowflakeParserMERGE = 472 + SnowflakeParserMIDDLE_NAME = 473 + SnowflakeParserMIN = 474 + SnowflakeParserMINS_TO_BYPASS_MFA = 475 + SnowflakeParserMINS_TO_UNLOCK = 476 + SnowflakeParserMINUS_ = 477 + SnowflakeParserMINUTES = 478 + SnowflakeParserMIN_CLUSTER_COUNT = 479 + SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS = 480 + SnowflakeParserMODE = 481 + SnowflakeParserMODIFIED_AFTER = 482 + SnowflakeParserMODIFY = 483 + SnowflakeParserMONITOR = 484 + SnowflakeParserMONITORS = 485 + SnowflakeParserMONTHLY = 486 + SnowflakeParserMOVE = 487 + SnowflakeParserMULTI_STATEMENT_COUNT = 488 + SnowflakeParserMULTI_USER = 489 + SnowflakeParserMUST_CHANGE = 490 + SnowflakeParserMUST_CHANGE_PASSWORD = 491 + SnowflakeParserNAME = 492 + SnowflakeParserNATURAL = 493 + SnowflakeParserNCHAR = 494 + SnowflakeParserNESTED_TRIGGERS = 495 + SnowflakeParserNETWORK = 496 + SnowflakeParserNETWORK_POLICY = 497 + SnowflakeParserNEVER = 498 + SnowflakeParserNEWID = 499 + SnowflakeParserNEWNAME = 500 + SnowflakeParserNEWSEQUENTIALID = 501 + SnowflakeParserNEW_ACCOUNT = 502 + SnowflakeParserNEW_BROKER = 503 + SnowflakeParserNEW_PASSWORD = 504 + SnowflakeParserNEXT = 505 + SnowflakeParserNEXTVAL = 506 + SnowflakeParserNO = 507 + SnowflakeParserNONE = 508 + SnowflakeParserNONE_Q = 509 + SnowflakeParserNORELY = 510 + SnowflakeParserNOT = 511 + SnowflakeParserNOTIFICATION = 512 + SnowflakeParserNOTIFICATIONS = 513 + SnowflakeParserNOTIFICATION_INTEGRATION = 514 + SnowflakeParserNOTIFICATION_PROVIDER = 515 + SnowflakeParserNOTIFY = 516 + SnowflakeParserNOTIFY_USERS = 517 + SnowflakeParserNOVALIDATE = 518 + SnowflakeParserNTILE = 519 + SnowflakeParserNULLIF = 520 + SnowflakeParserNULLS = 521 + SnowflakeParserNULL_ = 522 + SnowflakeParserNULL_IF = 523 + SnowflakeParserNUMANODE = 524 + SnowflakeParserNUMBER = 525 + SnowflakeParserNUMERIC_ROUNDABORT = 526 + SnowflakeParserNVL = 527 + SnowflakeParserOAUTH = 528 + SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI = 529 + SnowflakeParserOAUTH_CLIENT = 530 + SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY = 531 + SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY_2 = 532 + SnowflakeParserOAUTH_ENFORCE_PKCE = 533 + SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS = 534 + SnowflakeParserOAUTH_REDIRECT_URI = 535 + SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY = 536 + SnowflakeParserOAUTH_USE_SECONDARY_ROLES = 537 + SnowflakeParserOBJECT = 538 + SnowflakeParserOBJECT_Q = 539 + SnowflakeParserOBJECTS = 540 + SnowflakeParserOBJECT_TYPES = 541 + SnowflakeParserOF = 542 + SnowflakeParserOFF = 543 + SnowflakeParserOFFSET = 544 + SnowflakeParserOFFSETS = 545 + SnowflakeParserOKTA = 546 + SnowflakeParserOKTA_PROVISIONER_Q = 547 + SnowflakeParserOKTA_Q = 548 + SnowflakeParserOLD = 549 + SnowflakeParserOLD_ACCOUNT = 550 + SnowflakeParserOLD_PASSWORD = 551 + SnowflakeParserOMIT = 552 + SnowflakeParserON = 553 + SnowflakeParserONE = 554 + SnowflakeParserONLINE = 555 + SnowflakeParserONLY = 556 + SnowflakeParserON_ERROR = 557 + SnowflakeParserON_FAILURE = 558 + SnowflakeParserOPEN = 559 + SnowflakeParserOPERATE = 560 + SnowflakeParserOPERATIONS = 561 + SnowflakeParserOPTIMIZATION = 562 + SnowflakeParserOPTION = 563 + SnowflakeParserOR = 564 + SnowflakeParserORC = 565 + SnowflakeParserORC_Q = 566 + SnowflakeParserORDER = 567 + SnowflakeParserORGADMIN = 568 + SnowflakeParserORGANIZATION = 569 + SnowflakeParserOUTBOUND = 570 + SnowflakeParserOUTER = 571 + SnowflakeParserOVER = 572 + SnowflakeParserOVERRIDE = 573 + SnowflakeParserOVERWRITE = 574 + SnowflakeParserOWNER = 575 + SnowflakeParserOWNERSHIP = 576 + SnowflakeParserPAGE = 577 + SnowflakeParserPARALLEL = 578 + SnowflakeParserPARAMETERS = 579 + SnowflakeParserPARAM_NODE = 580 + SnowflakeParserPARQUET = 581 + SnowflakeParserPARQUET_Q = 582 + SnowflakeParserPARTIAL = 583 + SnowflakeParserPARTITION = 584 + SnowflakeParserPARTITIONS = 585 + SnowflakeParserPARTITION_TYPE = 586 + SnowflakeParserPASSWORD = 587 + SnowflakeParserPAST = 588 + SnowflakeParserPATH_ = 589 + SnowflakeParserPATTERN = 590 + SnowflakeParserPER = 591 + SnowflakeParserPERCENT = 592 + SnowflakeParserPERCENTILE_CONT = 593 + SnowflakeParserPERCENTILE_DISC = 594 + SnowflakeParserPERCENT_RANK = 595 + SnowflakeParserPERIODIC_DATA_REKEYING = 596 + SnowflakeParserPERMISSION_SET = 597 + SnowflakeParserPERSISTED = 598 + SnowflakeParserPERSIST_SAMPLE_PERCENT = 599 + SnowflakeParserPING_FEDERATE = 600 + SnowflakeParserPIPE = 601 + SnowflakeParserPIPES = 602 + SnowflakeParserPIPE_EXECUTION_PAUSED = 603 + SnowflakeParserPIVOT = 604 + SnowflakeParserPLAN = 605 + SnowflakeParserPLATFORM = 606 + SnowflakeParserPOLICIES = 607 + SnowflakeParserPOLICY = 608 + SnowflakeParserPOOL = 609 + SnowflakeParserPORT = 610 + SnowflakeParserPRECEDING = 611 + SnowflakeParserPRECISION = 612 + SnowflakeParserPREDICATE = 613 + SnowflakeParserPREFIX = 614 + SnowflakeParserPRESERVE_SPACE = 615 + SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL = 616 + SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES = 617 + SnowflakeParserPRE_AUTHORIZED_ROLES_LIST = 618 + SnowflakeParserPRIMARY = 619 + SnowflakeParserPRIMARY_ROLE = 620 + SnowflakeParserPRIOR = 621 + SnowflakeParserPRIORITY = 622 + SnowflakeParserPRIORITY_LEVEL = 623 + SnowflakeParserPRIVATE = 624 + SnowflakeParserPRIVATE_KEY = 625 + SnowflakeParserPRIVILEGES = 626 + SnowflakeParserPROC = 627 + SnowflakeParserPROCEDURE = 628 + SnowflakeParserPROCEDURES = 629 + SnowflakeParserPROCEDURE_NAME = 630 + SnowflakeParserPROCESS = 631 + SnowflakeParserPROFILE = 632 + SnowflakeParserPROPERTY = 633 + SnowflakeParserPROVIDER = 634 + SnowflakeParserPROVIDER_KEY_NAME = 635 + SnowflakeParserPUBLIC = 636 + SnowflakeParserPURGE = 637 + SnowflakeParserPUT = 638 + SnowflakeParserPYTHON = 639 + SnowflakeParserQUALIFY = 640 + SnowflakeParserQUERIES = 641 + SnowflakeParserQUERY = 642 + SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR = 643 + SnowflakeParserQUERY_TAG = 644 + SnowflakeParserQUEUE = 645 + SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE = 646 + SnowflakeParserRANGE = 647 + SnowflakeParserRANK = 648 + SnowflakeParserRAW_DEFLATE = 649 + SnowflakeParserREAD = 650 + SnowflakeParserREADER = 651 + SnowflakeParserREADONLY = 652 + SnowflakeParserREADPAST = 653 + SnowflakeParserREADTEXT = 654 + SnowflakeParserREADWRITE = 655 + SnowflakeParserREAD_COMMITTED_SNAPSHOT = 656 + SnowflakeParserREAD_ONLY = 657 + SnowflakeParserREAD_ONLY_ROUTING_LIST = 658 + SnowflakeParserREAD_WRITE = 659 + SnowflakeParserREBUILD = 660 + SnowflakeParserRECEIVE = 661 + SnowflakeParserRECLUSTER = 662 + SnowflakeParserRECOMPILE = 663 + SnowflakeParserRECONFIGURE = 664 + SnowflakeParserRECORD_DELIMITER = 665 + SnowflakeParserRECOVERY = 666 + SnowflakeParserRECURSIVE = 667 + SnowflakeParserRECURSIVE_TRIGGERS = 668 + SnowflakeParserREFERENCES = 669 + SnowflakeParserREFERENCE_USAGE = 670 + SnowflakeParserREFRESH = 671 + SnowflakeParserREFRESH_ON_CREATE = 672 + SnowflakeParserREGION = 673 + SnowflakeParserREGIONS = 674 + SnowflakeParserREGION_GROUP = 675 + SnowflakeParserRELATIVE = 676 + SnowflakeParserRELY = 677 + SnowflakeParserREMOTE = 678 + SnowflakeParserREMOTE_PROC_TRANSACTIONS = 679 + SnowflakeParserREMOTE_SERVICE_NAME = 680 + SnowflakeParserREMOVE = 681 + SnowflakeParserRENAME = 682 + SnowflakeParserREPEATABLE = 683 + SnowflakeParserREPLACE = 684 + SnowflakeParserREPLACE_INVALID_CHARACTERS = 685 + SnowflakeParserREPLICA = 686 + SnowflakeParserREPLICATION = 687 + SnowflakeParserREPLICATION_SCHEDULE = 688 + SnowflakeParserREQUEST_TRANSLATOR = 689 + SnowflakeParserREQUIRED = 690 + SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION = 691 + SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION = 692 + SnowflakeParserRESET = 693 + SnowflakeParserRESOURCE = 694 + SnowflakeParserRESOURCES = 695 + SnowflakeParserRESOURCE_MONITOR = 696 + SnowflakeParserRESPONSE_TRANSLATOR = 697 + SnowflakeParserRESTART = 698 + SnowflakeParserRESTORE = 699 + SnowflakeParserRESTRICT = 700 + SnowflakeParserRESTRICTIONS = 701 + SnowflakeParserRESULT = 702 + SnowflakeParserRESUME = 703 + SnowflakeParserRETAINDAYS = 704 + SnowflakeParserRETURN = 705 + SnowflakeParserRETURNS = 706 + SnowflakeParserRETURN_ALL_ERRORS = 707 + SnowflakeParserRETURN_ERRORS = 708 + SnowflakeParserRETURN_FAILED_ONLY = 709 + SnowflakeParserRETURN_N_ROWS = 710 + SnowflakeParserRETURN_ROWS = 711 + SnowflakeParserREVERSE = 712 + SnowflakeParserREVERT = 713 + SnowflakeParserREVOKE = 714 + SnowflakeParserREWIND = 715 + SnowflakeParserRIGHT = 716 + SnowflakeParserRLIKE = 717 + SnowflakeParserROLE = 718 + SnowflakeParserROLES = 719 + SnowflakeParserROLLBACK = 720 + SnowflakeParserROLLUP = 721 + SnowflakeParserROOT = 722 + SnowflakeParserROW = 723 + SnowflakeParserROWCOUNT = 724 + SnowflakeParserROWGUID = 725 + SnowflakeParserROWLOCK = 726 + SnowflakeParserROWS = 727 + SnowflakeParserROWS_PER_RESULTSET = 728 + SnowflakeParserROW_NUMBER = 729 + SnowflakeParserRSA_PUBLIC_KEY = 730 + SnowflakeParserRSA_PUBLIC_KEY_2 = 731 + SnowflakeParserRTRIM = 732 + SnowflakeParserRUN_AS_ROLE = 733 + SnowflakeParserS3 = 734 + SnowflakeParserSAFE = 735 + SnowflakeParserSAFETY = 736 + SnowflakeParserSAML2 = 737 + SnowflakeParserSAML2_ENABLE_SP_INITIATED = 738 + SnowflakeParserSAML2_FORCE_AUTHN = 739 + SnowflakeParserSAML2_ISSUER = 740 + SnowflakeParserSAML2_POST_LOGOUT_REDIRECT_URL = 741 + SnowflakeParserSAML2_PROVIDER = 742 + SnowflakeParserSAML2_REQUESTED_NAMEID_FORMAT = 743 + SnowflakeParserSAML2_SIGN_REQUEST = 744 + SnowflakeParserSAML2_SNOWFLAKE_ACS_URL = 745 + SnowflakeParserSAML2_SNOWFLAKE_ISSUER_URL = 746 + SnowflakeParserSAML2_SNOWFLAKE_X509_CERT = 747 + SnowflakeParserSAML2_SP_INITIATED_LOGIN_PAGE_LABEL = 748 + SnowflakeParserSAML2_SSO_URL = 749 + SnowflakeParserSAML2_X509_CERT = 750 + SnowflakeParserSAML_IDENTITY_PROVIDER = 751 + SnowflakeParserSAMPLE = 752 + SnowflakeParserSAVE_OLD_URL = 753 + SnowflakeParserSCALING_POLICY = 754 + SnowflakeParserSCHEDULE = 755 + SnowflakeParserSCHEDULER = 756 + SnowflakeParserSCHEMA = 757 + SnowflakeParserSCHEMAS = 758 + SnowflakeParserSCHEME = 759 + SnowflakeParserSCIM = 760 + SnowflakeParserSCIM_CLIENT = 761 + SnowflakeParserSCRIPT = 762 + SnowflakeParserSEARCH = 763 + SnowflakeParserSECONDARY = 764 + SnowflakeParserSECONDARY_ONLY = 765 + SnowflakeParserSECONDARY_ROLE = 766 + SnowflakeParserSECONDS = 767 + SnowflakeParserSECRET = 768 + SnowflakeParserSECURE = 769 + SnowflakeParserSECURITY = 770 + SnowflakeParserSECURITYADMIN = 771 + SnowflakeParserSEED = 772 + SnowflakeParserSELECT = 773 + SnowflakeParserSELF = 774 + SnowflakeParserSEQUENCE = 775 + SnowflakeParserSEQUENCES = 776 + SnowflakeParserSERVER = 777 + SnowflakeParserSERVICE = 778 + SnowflakeParserSESSION = 779 + SnowflakeParserSESSION_IDLE_TIMEOUT_MINS = 780 + SnowflakeParserSESSION_POLICY = 781 + SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS = 782 + SnowflakeParserSET = 783 + SnowflakeParserSETS = 784 + SnowflakeParserSETUSER = 785 + SnowflakeParserSHARE = 786 + SnowflakeParserSHARED = 787 + SnowflakeParserSHARES = 788 + SnowflakeParserSHARE_RESTRICTIONS = 789 + SnowflakeParserSHOW = 790 + SnowflakeParserSHOWPLAN = 791 + SnowflakeParserSHOWPLAN_ALL = 792 + SnowflakeParserSHOWPLAN_TEXT = 793 + SnowflakeParserSHOWPLAN_XML = 794 + SnowflakeParserSHOW_INITIAL_ROWS = 795 + SnowflakeParserSIGNATURE = 796 + SnowflakeParserSIMPLE = 797 + SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER = 798 + SnowflakeParserSINGLE_USER = 799 + SnowflakeParserSIZE = 800 + SnowflakeParserSIZE_LIMIT = 801 + SnowflakeParserSKIP_ = 802 + SnowflakeParserSKIP_BLANK_LINES = 803 + SnowflakeParserSKIP_BYTE_ORDER_MARK = 804 + SnowflakeParserSKIP_FILE = 805 + SnowflakeParserSKIP_FILE_N = 806 + SnowflakeParserSKIP_HEADER = 807 + SnowflakeParserSMALL = 808 + SnowflakeParserSNAPPY = 809 + SnowflakeParserSNAPPY_COMPRESSION = 810 + SnowflakeParserSOME = 811 + SnowflakeParserSOUNDEX = 812 + SnowflakeParserSOURCE = 813 + SnowflakeParserSOURCE_COMPRESSION = 814 + SnowflakeParserSPACE_KEYWORD = 815 + SnowflakeParserSPARSE = 816 + SnowflakeParserSPECIFICATION = 817 + SnowflakeParserSPLIT = 818 + SnowflakeParserSPLIT_PART = 819 + SnowflakeParserSQL = 820 + SnowflakeParserSSO_LOGIN_PAGE = 821 + SnowflakeParserSTAGE = 822 + SnowflakeParserSTAGES = 823 + SnowflakeParserSTAGE_COPY_OPTIONS = 824 + SnowflakeParserSTAGE_FILE_FORMAT = 825 + SnowflakeParserSTANDARD = 826 + SnowflakeParserSTANDBY = 827 + SnowflakeParserSTART = 828 + SnowflakeParserSTARTED = 829 + SnowflakeParserSTARTS = 830 + SnowflakeParserSTART_DATE = 831 + SnowflakeParserSTART_TIMESTAMP = 832 + SnowflakeParserSTATE = 833 + SnowflakeParserSTATEMENT = 834 + SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS = 835 + SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS = 836 + SnowflakeParserSTATIC = 837 + SnowflakeParserSTATISTICS = 838 + SnowflakeParserSTATS = 839 + SnowflakeParserSTATS_DATE = 840 + SnowflakeParserSTATS_STREAM = 841 + SnowflakeParserSTATUS = 842 + SnowflakeParserSTATUSONLY = 843 + SnowflakeParserSTDEV = 844 + SnowflakeParserSTDEVP = 845 + SnowflakeParserSTOP = 846 + SnowflakeParserSTOPLIST = 847 + SnowflakeParserSTOPPED = 848 + SnowflakeParserSTORAGE = 849 + SnowflakeParserSTORAGE_ALLOWED_LOCATIONS = 850 + SnowflakeParserSTORAGE_AWS_OBJECT_ACL = 851 + SnowflakeParserSTORAGE_AWS_ROLE_ARN = 852 + SnowflakeParserSTORAGE_BLOCKED_LOCATIONS = 853 + SnowflakeParserSTORAGE_INTEGRATION = 854 + SnowflakeParserSTORAGE_PROVIDER = 855 + SnowflakeParserSTR = 856 + SnowflakeParserSTREAM = 857 + SnowflakeParserSTREAMS = 858 + SnowflakeParserSTRICT = 859 + SnowflakeParserSTRICT_JSON_OUTPUT = 860 + SnowflakeParserSTRING_AGG = 861 + SnowflakeParserSTRING_ESCAPE = 862 + SnowflakeParserSTRIP_NULL_VALUES = 863 + SnowflakeParserSTRIP_OUTER_ARRAY = 864 + SnowflakeParserSTRIP_OUTER_ELEMENT = 865 + SnowflakeParserSUBSTR = 866 + SnowflakeParserSUBSTRING = 867 + SnowflakeParserSUM = 868 + SnowflakeParserSUPPORTED = 869 + SnowflakeParserSUSPEND = 870 + SnowflakeParserSUSPENDED = 871 + SnowflakeParserSUSPEND_IMMEDIATE = 872 + SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES = 873 + SnowflakeParserSWAP = 874 + SnowflakeParserSWITCH = 875 + SnowflakeParserSYNC_PASSWORD = 876 + SnowflakeParserSYSADMIN = 877 + SnowflakeParserSYSTEM = 878 + SnowflakeParserSYSTEM_USER = 879 + SnowflakeParserTABLE = 880 + SnowflakeParserTABLEAU_DESKTOP = 881 + SnowflakeParserTABLEAU_SERVER = 882 + SnowflakeParserTABLES = 883 + SnowflakeParserTABLESAMPLE = 884 + SnowflakeParserTABLE_FORMAT = 885 + SnowflakeParserTABULAR = 886 + SnowflakeParserTAG = 887 + SnowflakeParserTAGS = 888 + SnowflakeParserTARGET = 889 + SnowflakeParserTARGET_LAG = 890 + SnowflakeParserTASK = 891 + SnowflakeParserTASKS = 892 + SnowflakeParserTEMP = 893 + SnowflakeParserTEMPORARY = 894 + SnowflakeParserTERSE = 895 + SnowflakeParserTEXTSIZE = 896 + SnowflakeParserTHEN = 897 + SnowflakeParserTIES = 898 + SnowflakeParserTIME = 899 + SnowflakeParserTIMEADD = 900 + SnowflakeParserTIMEDIFF = 901 + SnowflakeParserTIMEOUT = 902 + SnowflakeParserTIMER = 903 + SnowflakeParserTIMESTAMP = 904 + SnowflakeParserTIMESTAMP_DAY_IS_ALWAYS_24H = 905 + SnowflakeParserTIMESTAMP_FORMAT = 906 + SnowflakeParserTIMESTAMP_INPUT_FORMAT = 907 + SnowflakeParserTIMESTAMP_LTZ = 908 + SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT = 909 + SnowflakeParserTIMESTAMP_NTZ = 910 + SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT = 911 + SnowflakeParserTIMESTAMP_OUTPUT_FORMAT = 912 + SnowflakeParserTIMESTAMP_TYPE_MAPPING = 913 + SnowflakeParserTIMESTAMP_TZ = 914 + SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT = 915 + SnowflakeParserTIMESTAMPADD = 916 + SnowflakeParserTIMESTAMPDIFF = 917 + SnowflakeParserTIMEZONE = 918 + SnowflakeParserTIME_FORMAT = 919 + SnowflakeParserTIME_INPUT_FORMAT = 920 + SnowflakeParserTIME_OUTPUT_FORMAT = 921 + SnowflakeParserTO = 922 + SnowflakeParserTO_BOOLEAN = 923 + SnowflakeParserTO_DATE = 924 + SnowflakeParserTOP = 925 + SnowflakeParserTORN_PAGE_DETECTION = 926 + SnowflakeParserTRACKING = 927 + SnowflakeParserTRACK_CAUSALITY = 928 + SnowflakeParserTRAN = 929 + SnowflakeParserTRANSACTION = 930 + SnowflakeParserTRANSACTIONS = 931 + SnowflakeParserTRANSACTION_ABORT_ON_ERROR = 932 + SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL = 933 + SnowflakeParserTRANSACTION_ID = 934 + SnowflakeParserTRANSFORM_NOISE_WORDS = 935 + SnowflakeParserTRANSIENT = 936 + SnowflakeParserTRANSLATE = 937 + SnowflakeParserTRIGGER = 938 + SnowflakeParserTRIGGERS = 939 + SnowflakeParserTRIM = 940 + SnowflakeParserTRIM_SPACE = 941 + SnowflakeParserTRIPLE_DES = 942 + SnowflakeParserTRIPLE_DES_3KEY = 943 + SnowflakeParserTRUE = 944 + SnowflakeParserTRUNCATE = 945 + SnowflakeParserTRUNCATECOLUMNS = 946 + SnowflakeParserTRUSTWORTHY = 947 + SnowflakeParserTRY = 948 + SnowflakeParserTRY_CAST = 949 + SnowflakeParserTSEQUAL = 950 + SnowflakeParserTSQL = 951 + SnowflakeParserTWO_DIGIT_CENTURY_START = 952 + SnowflakeParserTWO_DIGIT_YEAR_CUTOFF = 953 + SnowflakeParserTYPE = 954 + SnowflakeParserTYPEPROPERTY = 955 + SnowflakeParserTYPE_ID = 956 + SnowflakeParserTYPE_NAME = 957 + SnowflakeParserTYPE_WARNING = 958 + SnowflakeParserUN = 959 + SnowflakeParserUNBOUNDED = 960 + SnowflakeParserUNCHECKED = 961 + SnowflakeParserUNCOMMITTED = 962 + SnowflakeParserUNDROP = 963 + SnowflakeParserUNICODE = 964 + SnowflakeParserUNION = 965 + SnowflakeParserUNIQUE = 966 + SnowflakeParserUNKNOWN = 967 + SnowflakeParserUNLIMITED = 968 + SnowflakeParserUNLOCK = 969 + SnowflakeParserUNMASK = 970 + SnowflakeParserUNMATCHED = 971 + SnowflakeParserUNPIVOT = 972 + SnowflakeParserUNSAFE = 973 + SnowflakeParserUNSET = 974 + SnowflakeParserUNSUPPORTED_DDL_ACTION = 975 + SnowflakeParserUOW = 976 + SnowflakeParserUPDATE = 977 + SnowflakeParserUPDLOCK = 978 + SnowflakeParserUPPER = 979 + SnowflakeParserURL = 980 + SnowflakeParserUSAGE = 981 + SnowflakeParserUSE = 982 + SnowflakeParserUSED = 983 + SnowflakeParserUSER = 984 + SnowflakeParserUSERADMIN = 985 + SnowflakeParserUSERS = 986 + SnowflakeParserUSER_SPECIFIED = 987 + SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE = 988 + SnowflakeParserUSER_TASK_TIMEOUT_MS = 989 + SnowflakeParserUSE_ANY_ROLE = 990 + SnowflakeParserUSE_CACHED_RESULT = 991 + SnowflakeParserUSING = 992 + SnowflakeParserUTF8 = 993 + SnowflakeParserVALIDATE = 994 + SnowflakeParserVALIDATION = 995 + SnowflakeParserVALIDATION_MODE = 996 + SnowflakeParserVALID_XML = 997 + SnowflakeParserVALUE = 998 + SnowflakeParserVALUES = 999 + SnowflakeParserVAR = 1000 + SnowflakeParserVARIABLES = 1001 + SnowflakeParserVARP = 1002 + SnowflakeParserVARYING = 1003 + SnowflakeParserVERSION = 1004 + SnowflakeParserVIEW = 1005 + SnowflakeParserVIEWS = 1006 + SnowflakeParserVIEW_METADATA = 1007 + SnowflakeParserVISIBILITY = 1008 + SnowflakeParserVOLATILE = 1009 + SnowflakeParserWAIT = 1010 + SnowflakeParserWAREHOUSE = 1011 + SnowflakeParserWAREHOUSES = 1012 + SnowflakeParserWAREHOUSE_SIZE = 1013 + SnowflakeParserWEEKLY = 1014 + SnowflakeParserWEEK_OF_YEAR_POLICY = 1015 + SnowflakeParserWEEK_START = 1016 + SnowflakeParserWELL_FORMED_XML = 1017 + SnowflakeParserWHEN = 1018 + SnowflakeParserWHERE = 1019 + SnowflakeParserWITH = 1020 + SnowflakeParserWITHIN = 1021 + SnowflakeParserWITHOUT = 1022 + SnowflakeParserWITHOUT_ARRAY_WRAPPER = 1023 + SnowflakeParserWORK = 1024 + SnowflakeParserWORKLOAD = 1025 + SnowflakeParserWRITE = 1026 + SnowflakeParserX4LARGE = 1027 + SnowflakeParserX5LARGE = 1028 + SnowflakeParserX6LARGE = 1029 + SnowflakeParserXLARGE = 1030 + SnowflakeParserXLOCK = 1031 + SnowflakeParserXML = 1032 + SnowflakeParserXML_Q = 1033 + SnowflakeParserXSMALL = 1034 + SnowflakeParserXXLARGE = 1035 + SnowflakeParserXXXLARGE = 1036 + SnowflakeParserYEARLY = 1037 + SnowflakeParserZSTD = 1038 + SnowflakeParserARRAY = 1039 + SnowflakeParserARRAY_Q = 1040 + SnowflakeParserBIGINT = 1041 + SnowflakeParserBINARY = 1042 + SnowflakeParserBOOLEAN = 1043 + SnowflakeParserBYTEINT = 1044 + SnowflakeParserCHAR_VARYING = 1045 + SnowflakeParserDATE = 1046 + SnowflakeParserDATETIME = 1047 + SnowflakeParserDECIMAL_ = 1048 + SnowflakeParserFLOAT4 = 1049 + SnowflakeParserFLOAT8 = 1050 + SnowflakeParserFLOAT_ = 1051 + SnowflakeParserGEOGRAPHY = 1052 + SnowflakeParserGEOMETRY = 1053 + SnowflakeParserINTEGER = 1054 + SnowflakeParserNCHAR_VARYING = 1055 + SnowflakeParserNUMERIC = 1056 + SnowflakeParserNVARCHAR2 = 1057 + SnowflakeParserNVARCHAR = 1058 + SnowflakeParserREAL_ = 1059 + SnowflakeParserSMALLINT = 1060 + SnowflakeParserSTRING_ = 1061 + SnowflakeParserTEXT = 1062 + SnowflakeParserTINYINT = 1063 + SnowflakeParserVARBINARY = 1064 + SnowflakeParserVARCHAR = 1065 + SnowflakeParserVARIANT = 1066 + SnowflakeParserLISTAGG = 1067 + SnowflakeParserDUMMY = 1068 + SnowflakeParserSPACE = 1069 + SnowflakeParserSQL_COMMENT = 1070 + SnowflakeParserLINE_COMMENT = 1071 + SnowflakeParserLINE_COMMENT_2 = 1072 + SnowflakeParserDOUBLE_QUOTE_ID = 1073 + SnowflakeParserDOUBLE_QUOTE_BLANK = 1074 + SnowflakeParserSINGLE_QUOTE = 1075 + SnowflakeParserID = 1076 + SnowflakeParserID2 = 1077 + SnowflakeParserS3_PATH = 1078 + SnowflakeParserGCS_PATH = 1079 + SnowflakeParserAZURE_PATH = 1080 + SnowflakeParserFILE_PATH = 1081 + SnowflakeParserDBL_DOLLAR = 1082 + SnowflakeParserSTRING = 1083 + SnowflakeParserDECIMAL = 1084 + SnowflakeParserFLOAT = 1085 + SnowflakeParserREAL = 1086 + SnowflakeParserCHAR_LITERAL = 1087 + SnowflakeParserARROW = 1088 + SnowflakeParserASSOC = 1089 + SnowflakeParserNE = 1090 + SnowflakeParserLTGT = 1091 + SnowflakeParserEQ = 1092 + SnowflakeParserGT = 1093 + SnowflakeParserGE = 1094 + SnowflakeParserLT = 1095 + SnowflakeParserLE = 1096 + SnowflakeParserEXCLAMATION = 1097 + SnowflakeParserPIPE_PIPE = 1098 + SnowflakeParserDOT = 1099 + SnowflakeParserUNDERLINE = 1100 + SnowflakeParserAT = 1101 + SnowflakeParserAT_Q = 1102 + SnowflakeParserDOLLAR = 1103 + SnowflakeParserLR_BRACKET = 1104 + SnowflakeParserRR_BRACKET = 1105 + SnowflakeParserLSB = 1106 + SnowflakeParserRSB = 1107 + SnowflakeParserLCB = 1108 + SnowflakeParserRCB = 1109 + SnowflakeParserCOMMA = 1110 + SnowflakeParserSEMI = 1111 + SnowflakeParserCOLON = 1112 + SnowflakeParserCOLON_COLON = 1113 + SnowflakeParserSTAR = 1114 + SnowflakeParserDIVIDE = 1115 + SnowflakeParserMODULE = 1116 + SnowflakeParserPLUS = 1117 + SnowflakeParserMINUS = 1118 + SnowflakeParserPLACEHOLDER = 1119 +) + +// SnowflakeParser rules. +const ( + SnowflakeParserRULE_snowflake_file = 0 + SnowflakeParserRULE_batch = 1 + SnowflakeParserRULE_sql_command = 2 + SnowflakeParserRULE_ddl_command = 3 + SnowflakeParserRULE_dml_command = 4 + SnowflakeParserRULE_insert_statement = 5 + SnowflakeParserRULE_insert_multi_table_statement = 6 + SnowflakeParserRULE_into_clause2 = 7 + SnowflakeParserRULE_values_list = 8 + SnowflakeParserRULE_value_item = 9 + SnowflakeParserRULE_merge_statement = 10 + SnowflakeParserRULE_merge_matches = 11 + SnowflakeParserRULE_merge_update_delete = 12 + SnowflakeParserRULE_merge_insert = 13 + SnowflakeParserRULE_update_statement = 14 + SnowflakeParserRULE_table_or_query = 15 + SnowflakeParserRULE_delete_statement = 16 + SnowflakeParserRULE_values_builder = 17 + SnowflakeParserRULE_other_command = 18 + SnowflakeParserRULE_copy_into_table = 19 + SnowflakeParserRULE_external_location = 20 + SnowflakeParserRULE_files = 21 + SnowflakeParserRULE_file_format = 22 + SnowflakeParserRULE_format_name = 23 + SnowflakeParserRULE_format_type = 24 + SnowflakeParserRULE_stage_file_format = 25 + SnowflakeParserRULE_copy_into_location = 26 + SnowflakeParserRULE_comment = 27 + SnowflakeParserRULE_commit = 28 + SnowflakeParserRULE_execute_immediate = 29 + SnowflakeParserRULE_execute_task = 30 + SnowflakeParserRULE_explain = 31 + SnowflakeParserRULE_parallel = 32 + SnowflakeParserRULE_get_dml = 33 + SnowflakeParserRULE_grant_ownership = 34 + SnowflakeParserRULE_grant_to_role = 35 + SnowflakeParserRULE_global_privileges = 36 + SnowflakeParserRULE_global_privilege = 37 + SnowflakeParserRULE_account_object_privileges = 38 + SnowflakeParserRULE_account_object_privilege = 39 + SnowflakeParserRULE_schema_privileges = 40 + SnowflakeParserRULE_schema_privilege = 41 + SnowflakeParserRULE_schema_object_privileges = 42 + SnowflakeParserRULE_schema_object_privilege = 43 + SnowflakeParserRULE_grant_to_share = 44 + SnowflakeParserRULE_object_privilege = 45 + SnowflakeParserRULE_grant_role = 46 + SnowflakeParserRULE_role_name = 47 + SnowflakeParserRULE_system_defined_role = 48 + SnowflakeParserRULE_list = 49 + SnowflakeParserRULE_internal_stage = 50 + SnowflakeParserRULE_external_stage = 51 + SnowflakeParserRULE_put = 52 + SnowflakeParserRULE_remove = 53 + SnowflakeParserRULE_revoke_from_role = 54 + SnowflakeParserRULE_revoke_from_share = 55 + SnowflakeParserRULE_revoke_role = 56 + SnowflakeParserRULE_rollback = 57 + SnowflakeParserRULE_set = 58 + SnowflakeParserRULE_truncate_materialized_view = 59 + SnowflakeParserRULE_truncate_table = 60 + SnowflakeParserRULE_unset = 61 + SnowflakeParserRULE_alter_command = 62 + SnowflakeParserRULE_account_params = 63 + SnowflakeParserRULE_object_params = 64 + SnowflakeParserRULE_default_ddl_collation = 65 + SnowflakeParserRULE_object_properties = 66 + SnowflakeParserRULE_session_params = 67 + SnowflakeParserRULE_alter_account = 68 + SnowflakeParserRULE_enabled_true_false = 69 + SnowflakeParserRULE_alter_alert = 70 + SnowflakeParserRULE_resume_suspend = 71 + SnowflakeParserRULE_alert_set_clause = 72 + SnowflakeParserRULE_alert_unset_clause = 73 + SnowflakeParserRULE_alter_api_integration = 74 + SnowflakeParserRULE_api_integration_property = 75 + SnowflakeParserRULE_alter_connection = 76 + SnowflakeParserRULE_alter_database = 77 + SnowflakeParserRULE_database_property = 78 + SnowflakeParserRULE_account_id_list = 79 + SnowflakeParserRULE_alter_dynamic_table = 80 + SnowflakeParserRULE_alter_external_table = 81 + SnowflakeParserRULE_ignore_edition_check = 82 + SnowflakeParserRULE_replication_schedule = 83 + SnowflakeParserRULE_db_name_list = 84 + SnowflakeParserRULE_share_name_list = 85 + SnowflakeParserRULE_full_acct_list = 86 + SnowflakeParserRULE_alter_failover_group = 87 + SnowflakeParserRULE_alter_file_format = 88 + SnowflakeParserRULE_alter_function = 89 + SnowflakeParserRULE_alter_function_signature = 90 + SnowflakeParserRULE_data_type_list = 91 + SnowflakeParserRULE_alter_masking_policy = 92 + SnowflakeParserRULE_alter_materialized_view = 93 + SnowflakeParserRULE_alter_network_policy = 94 + SnowflakeParserRULE_alter_notification_integration = 95 + SnowflakeParserRULE_alter_pipe = 96 + SnowflakeParserRULE_alter_procedure = 97 + SnowflakeParserRULE_alter_replication_group = 98 + SnowflakeParserRULE_credit_quota = 99 + SnowflakeParserRULE_frequency = 100 + SnowflakeParserRULE_notify_users = 101 + SnowflakeParserRULE_triggerDefinition = 102 + SnowflakeParserRULE_alter_resource_monitor = 103 + SnowflakeParserRULE_alter_role = 104 + SnowflakeParserRULE_alter_row_access_policy = 105 + SnowflakeParserRULE_alter_schema = 106 + SnowflakeParserRULE_schema_property = 107 + SnowflakeParserRULE_alter_security_integration = 108 + SnowflakeParserRULE_alter_security_integration_external_oauth = 109 + SnowflakeParserRULE_security_integration_external_oauth_property = 110 + SnowflakeParserRULE_alter_security_integration_snowflake_oauth = 111 + SnowflakeParserRULE_security_integration_snowflake_oauth_property = 112 + SnowflakeParserRULE_alter_security_integration_saml2 = 113 + SnowflakeParserRULE_alter_security_integration_scim = 114 + SnowflakeParserRULE_security_integration_scim_property = 115 + SnowflakeParserRULE_alter_sequence = 116 + SnowflakeParserRULE_alter_session = 117 + SnowflakeParserRULE_alter_session_policy = 118 + SnowflakeParserRULE_alter_share = 119 + SnowflakeParserRULE_alter_stage = 120 + SnowflakeParserRULE_alter_storage_integration = 121 + SnowflakeParserRULE_alter_stream = 122 + SnowflakeParserRULE_alter_table = 123 + SnowflakeParserRULE_clustering_action = 124 + SnowflakeParserRULE_table_column_action = 125 + SnowflakeParserRULE_inline_constraint = 126 + SnowflakeParserRULE_constraint_properties = 127 + SnowflakeParserRULE_ext_table_column_action = 128 + SnowflakeParserRULE_constraint_action = 129 + SnowflakeParserRULE_search_optimization_action = 130 + SnowflakeParserRULE_search_method_with_target = 131 + SnowflakeParserRULE_alter_table_alter_column = 132 + SnowflakeParserRULE_alter_column_decl_list = 133 + SnowflakeParserRULE_alter_column_decl = 134 + SnowflakeParserRULE_alter_column_opts = 135 + SnowflakeParserRULE_column_set_tags = 136 + SnowflakeParserRULE_column_unset_tags = 137 + SnowflakeParserRULE_alter_tag = 138 + SnowflakeParserRULE_alter_task = 139 + SnowflakeParserRULE_alter_user = 140 + SnowflakeParserRULE_alter_view = 141 + SnowflakeParserRULE_alter_modify = 142 + SnowflakeParserRULE_alter_warehouse = 143 + SnowflakeParserRULE_alter_connection_opts = 144 + SnowflakeParserRULE_alter_user_opts = 145 + SnowflakeParserRULE_alter_tag_opts = 146 + SnowflakeParserRULE_alter_network_policy_opts = 147 + SnowflakeParserRULE_alter_warehouse_opts = 148 + SnowflakeParserRULE_alter_account_opts = 149 + SnowflakeParserRULE_set_tags = 150 + SnowflakeParserRULE_tag_decl_list = 151 + SnowflakeParserRULE_unset_tags = 152 + SnowflakeParserRULE_create_command = 153 + SnowflakeParserRULE_create_account = 154 + SnowflakeParserRULE_create_alert = 155 + SnowflakeParserRULE_alert_condition = 156 + SnowflakeParserRULE_alert_action = 157 + SnowflakeParserRULE_create_api_integration = 158 + SnowflakeParserRULE_create_object_clone = 159 + SnowflakeParserRULE_create_connection = 160 + SnowflakeParserRULE_create_database = 161 + SnowflakeParserRULE_create_dynamic_table = 162 + SnowflakeParserRULE_clone_at_before = 163 + SnowflakeParserRULE_at_before1 = 164 + SnowflakeParserRULE_header_decl = 165 + SnowflakeParserRULE_compression_type = 166 + SnowflakeParserRULE_compression = 167 + SnowflakeParserRULE_create_external_function = 168 + SnowflakeParserRULE_create_external_table = 169 + SnowflakeParserRULE_external_table_column_decl = 170 + SnowflakeParserRULE_external_table_column_decl_list = 171 + SnowflakeParserRULE_full_acct = 172 + SnowflakeParserRULE_integration_type_name = 173 + SnowflakeParserRULE_create_failover_group = 174 + SnowflakeParserRULE_type_fileformat = 175 + SnowflakeParserRULE_create_file_format = 176 + SnowflakeParserRULE_arg_decl = 177 + SnowflakeParserRULE_col_decl = 178 + SnowflakeParserRULE_function_definition = 179 + SnowflakeParserRULE_create_function = 180 + SnowflakeParserRULE_create_managed_account = 181 + SnowflakeParserRULE_create_masking_policy = 182 + SnowflakeParserRULE_tag_decl = 183 + SnowflakeParserRULE_column_list_in_parentheses = 184 + SnowflakeParserRULE_create_materialized_view = 185 + SnowflakeParserRULE_create_network_policy = 186 + SnowflakeParserRULE_cloud_provider_params_auto = 187 + SnowflakeParserRULE_cloud_provider_params_push = 188 + SnowflakeParserRULE_create_notification_integration = 189 + SnowflakeParserRULE_create_pipe = 190 + SnowflakeParserRULE_caller_owner = 191 + SnowflakeParserRULE_executa_as = 192 + SnowflakeParserRULE_procedure_definition = 193 + SnowflakeParserRULE_create_procedure = 194 + SnowflakeParserRULE_create_replication_group = 195 + SnowflakeParserRULE_create_resource_monitor = 196 + SnowflakeParserRULE_create_role = 197 + SnowflakeParserRULE_create_row_access_policy = 198 + SnowflakeParserRULE_create_schema = 199 + SnowflakeParserRULE_create_security_integration_external_oauth = 200 + SnowflakeParserRULE_implicit_none = 201 + SnowflakeParserRULE_create_security_integration_snowflake_oauth = 202 + SnowflakeParserRULE_create_security_integration_saml2 = 203 + SnowflakeParserRULE_create_security_integration_scim = 204 + SnowflakeParserRULE_network_policy = 205 + SnowflakeParserRULE_partner_application = 206 + SnowflakeParserRULE_start_with = 207 + SnowflakeParserRULE_increment_by = 208 + SnowflakeParserRULE_create_sequence = 209 + SnowflakeParserRULE_create_session_policy = 210 + SnowflakeParserRULE_create_share = 211 + SnowflakeParserRULE_character = 212 + SnowflakeParserRULE_format_type_options = 213 + SnowflakeParserRULE_copy_options = 214 + SnowflakeParserRULE_internal_stage_params = 215 + SnowflakeParserRULE_stage_type = 216 + SnowflakeParserRULE_stage_master_key = 217 + SnowflakeParserRULE_stage_kms_key = 218 + SnowflakeParserRULE_stage_encryption_opts_aws = 219 + SnowflakeParserRULE_aws_token = 220 + SnowflakeParserRULE_aws_key_id = 221 + SnowflakeParserRULE_aws_secret_key = 222 + SnowflakeParserRULE_aws_role = 223 + SnowflakeParserRULE_external_stage_params = 224 + SnowflakeParserRULE_true_false = 225 + SnowflakeParserRULE_enable = 226 + SnowflakeParserRULE_refresh_on_create = 227 + SnowflakeParserRULE_auto_refresh = 228 + SnowflakeParserRULE_notification_integration = 229 + SnowflakeParserRULE_directory_table_params = 230 + SnowflakeParserRULE_create_stage = 231 + SnowflakeParserRULE_cloud_provider_params = 232 + SnowflakeParserRULE_cloud_provider_params2 = 233 + SnowflakeParserRULE_cloud_provider_params3 = 234 + SnowflakeParserRULE_create_storage_integration = 235 + SnowflakeParserRULE_copy_grants = 236 + SnowflakeParserRULE_append_only = 237 + SnowflakeParserRULE_insert_only = 238 + SnowflakeParserRULE_show_initial_rows = 239 + SnowflakeParserRULE_stream_time = 240 + SnowflakeParserRULE_create_stream = 241 + SnowflakeParserRULE_temporary = 242 + SnowflakeParserRULE_table_type = 243 + SnowflakeParserRULE_with_tags = 244 + SnowflakeParserRULE_with_row_access_policy = 245 + SnowflakeParserRULE_cluster_by = 246 + SnowflakeParserRULE_change_tracking = 247 + SnowflakeParserRULE_with_masking_policy = 248 + SnowflakeParserRULE_collate = 249 + SnowflakeParserRULE_not_null = 250 + SnowflakeParserRULE_default_value = 251 + SnowflakeParserRULE_foreign_key = 252 + SnowflakeParserRULE_out_of_line_constraint = 253 + SnowflakeParserRULE_full_col_decl = 254 + SnowflakeParserRULE_column_decl_item = 255 + SnowflakeParserRULE_column_decl_item_list = 256 + SnowflakeParserRULE_create_table = 257 + SnowflakeParserRULE_create_table_as_select = 258 + SnowflakeParserRULE_create_tag = 259 + SnowflakeParserRULE_session_parameter = 260 + SnowflakeParserRULE_session_parameter_list = 261 + SnowflakeParserRULE_session_parameter_init_list = 262 + SnowflakeParserRULE_session_parameter_init = 263 + SnowflakeParserRULE_create_task = 264 + SnowflakeParserRULE_sql = 265 + SnowflakeParserRULE_call = 266 + SnowflakeParserRULE_create_user = 267 + SnowflakeParserRULE_view_col = 268 + SnowflakeParserRULE_create_view = 269 + SnowflakeParserRULE_create_warehouse = 270 + SnowflakeParserRULE_wh_properties = 271 + SnowflakeParserRULE_wh_params = 272 + SnowflakeParserRULE_trigger_definition = 273 + SnowflakeParserRULE_object_type_name = 274 + SnowflakeParserRULE_object_type_plural = 275 + SnowflakeParserRULE_drop_command = 276 + SnowflakeParserRULE_drop_object = 277 + SnowflakeParserRULE_drop_alert = 278 + SnowflakeParserRULE_drop_connection = 279 + SnowflakeParserRULE_drop_database = 280 + SnowflakeParserRULE_drop_dynamic_table = 281 + SnowflakeParserRULE_drop_external_table = 282 + SnowflakeParserRULE_drop_failover_group = 283 + SnowflakeParserRULE_drop_file_format = 284 + SnowflakeParserRULE_drop_function = 285 + SnowflakeParserRULE_drop_integration = 286 + SnowflakeParserRULE_drop_managed_account = 287 + SnowflakeParserRULE_drop_masking_policy = 288 + SnowflakeParserRULE_drop_materialized_view = 289 + SnowflakeParserRULE_drop_network_policy = 290 + SnowflakeParserRULE_drop_pipe = 291 + SnowflakeParserRULE_drop_procedure = 292 + SnowflakeParserRULE_drop_replication_group = 293 + SnowflakeParserRULE_drop_resource_monitor = 294 + SnowflakeParserRULE_drop_role = 295 + SnowflakeParserRULE_drop_row_access_policy = 296 + SnowflakeParserRULE_drop_schema = 297 + SnowflakeParserRULE_drop_sequence = 298 + SnowflakeParserRULE_drop_session_policy = 299 + SnowflakeParserRULE_drop_share = 300 + SnowflakeParserRULE_drop_stage = 301 + SnowflakeParserRULE_drop_stream = 302 + SnowflakeParserRULE_drop_table = 303 + SnowflakeParserRULE_drop_tag = 304 + SnowflakeParserRULE_drop_task = 305 + SnowflakeParserRULE_drop_user = 306 + SnowflakeParserRULE_drop_view = 307 + SnowflakeParserRULE_drop_warehouse = 308 + SnowflakeParserRULE_cascade_restrict = 309 + SnowflakeParserRULE_arg_types = 310 + SnowflakeParserRULE_undrop_command = 311 + SnowflakeParserRULE_undrop_database = 312 + SnowflakeParserRULE_undrop_dynamic_table = 313 + SnowflakeParserRULE_undrop_schema = 314 + SnowflakeParserRULE_undrop_table = 315 + SnowflakeParserRULE_undrop_tag = 316 + SnowflakeParserRULE_use_command = 317 + SnowflakeParserRULE_use_database = 318 + SnowflakeParserRULE_use_role = 319 + SnowflakeParserRULE_use_schema = 320 + SnowflakeParserRULE_use_secondary_roles = 321 + SnowflakeParserRULE_use_warehouse = 322 + SnowflakeParserRULE_comment_clause = 323 + SnowflakeParserRULE_if_suspended = 324 + SnowflakeParserRULE_if_exists = 325 + SnowflakeParserRULE_if_not_exists = 326 + SnowflakeParserRULE_or_replace = 327 + SnowflakeParserRULE_describe = 328 + SnowflakeParserRULE_describe_command = 329 + SnowflakeParserRULE_describe_alert = 330 + SnowflakeParserRULE_describe_database = 331 + SnowflakeParserRULE_describe_dynamic_table = 332 + SnowflakeParserRULE_describe_external_table = 333 + SnowflakeParserRULE_describe_file_format = 334 + SnowflakeParserRULE_describe_function = 335 + SnowflakeParserRULE_describe_integration = 336 + SnowflakeParserRULE_describe_masking_policy = 337 + SnowflakeParserRULE_describe_materialized_view = 338 + SnowflakeParserRULE_describe_network_policy = 339 + SnowflakeParserRULE_describe_pipe = 340 + SnowflakeParserRULE_describe_procedure = 341 + SnowflakeParserRULE_describe_result = 342 + SnowflakeParserRULE_describe_row_access_policy = 343 + SnowflakeParserRULE_describe_schema = 344 + SnowflakeParserRULE_describe_search_optimization = 345 + SnowflakeParserRULE_describe_sequence = 346 + SnowflakeParserRULE_describe_session_policy = 347 + SnowflakeParserRULE_describe_share = 348 + SnowflakeParserRULE_describe_stage = 349 + SnowflakeParserRULE_describe_stream = 350 + SnowflakeParserRULE_describe_table = 351 + SnowflakeParserRULE_describe_task = 352 + SnowflakeParserRULE_describe_transaction = 353 + SnowflakeParserRULE_describe_user = 354 + SnowflakeParserRULE_describe_view = 355 + SnowflakeParserRULE_describe_warehouse = 356 + SnowflakeParserRULE_show_command = 357 + SnowflakeParserRULE_show_alerts = 358 + SnowflakeParserRULE_show_columns = 359 + SnowflakeParserRULE_show_connections = 360 + SnowflakeParserRULE_starts_with = 361 + SnowflakeParserRULE_limit_rows = 362 + SnowflakeParserRULE_show_databases = 363 + SnowflakeParserRULE_show_databases_in_failover_group = 364 + SnowflakeParserRULE_show_databases_in_replication_group = 365 + SnowflakeParserRULE_show_delegated_authorizations = 366 + SnowflakeParserRULE_show_external_functions = 367 + SnowflakeParserRULE_show_dynamic_tables = 368 + SnowflakeParserRULE_show_external_tables = 369 + SnowflakeParserRULE_show_failover_groups = 370 + SnowflakeParserRULE_show_file_formats = 371 + SnowflakeParserRULE_show_functions = 372 + SnowflakeParserRULE_show_global_accounts = 373 + SnowflakeParserRULE_show_grants = 374 + SnowflakeParserRULE_show_grants_opts = 375 + SnowflakeParserRULE_show_integrations = 376 + SnowflakeParserRULE_show_locks = 377 + SnowflakeParserRULE_show_managed_accounts = 378 + SnowflakeParserRULE_show_masking_policies = 379 + SnowflakeParserRULE_in_obj = 380 + SnowflakeParserRULE_in_obj_2 = 381 + SnowflakeParserRULE_show_materialized_views = 382 + SnowflakeParserRULE_show_network_policies = 383 + SnowflakeParserRULE_show_objects = 384 + SnowflakeParserRULE_show_organization_accounts = 385 + SnowflakeParserRULE_in_for = 386 + SnowflakeParserRULE_show_parameters = 387 + SnowflakeParserRULE_show_pipes = 388 + SnowflakeParserRULE_show_primary_keys = 389 + SnowflakeParserRULE_show_procedures = 390 + SnowflakeParserRULE_show_regions = 391 + SnowflakeParserRULE_show_replication_accounts = 392 + SnowflakeParserRULE_show_replication_databases = 393 + SnowflakeParserRULE_show_replication_groups = 394 + SnowflakeParserRULE_show_resource_monitors = 395 + SnowflakeParserRULE_show_roles = 396 + SnowflakeParserRULE_show_row_access_policies = 397 + SnowflakeParserRULE_show_schemas = 398 + SnowflakeParserRULE_show_sequences = 399 + SnowflakeParserRULE_show_session_policies = 400 + SnowflakeParserRULE_show_shares = 401 + SnowflakeParserRULE_show_shares_in_failover_group = 402 + SnowflakeParserRULE_show_shares_in_replication_group = 403 + SnowflakeParserRULE_show_stages = 404 + SnowflakeParserRULE_show_streams = 405 + SnowflakeParserRULE_show_tables = 406 + SnowflakeParserRULE_show_tags = 407 + SnowflakeParserRULE_show_tasks = 408 + SnowflakeParserRULE_show_transactions = 409 + SnowflakeParserRULE_show_user_functions = 410 + SnowflakeParserRULE_show_users = 411 + SnowflakeParserRULE_show_variables = 412 + SnowflakeParserRULE_show_views = 413 + SnowflakeParserRULE_show_warehouses = 414 + SnowflakeParserRULE_like_pattern = 415 + SnowflakeParserRULE_account_identifier = 416 + SnowflakeParserRULE_schema_name = 417 + SnowflakeParserRULE_object_type = 418 + SnowflakeParserRULE_object_type_list = 419 + SnowflakeParserRULE_tag_value = 420 + SnowflakeParserRULE_arg_data_type = 421 + SnowflakeParserRULE_arg_name = 422 + SnowflakeParserRULE_param_name = 423 + SnowflakeParserRULE_region_group_id = 424 + SnowflakeParserRULE_snowflake_region_id = 425 + SnowflakeParserRULE_string = 426 + SnowflakeParserRULE_string_list = 427 + SnowflakeParserRULE_id_ = 428 + SnowflakeParserRULE_keyword = 429 + SnowflakeParserRULE_non_reserved_words = 430 + SnowflakeParserRULE_builtin_function = 431 + SnowflakeParserRULE_list_operator = 432 + SnowflakeParserRULE_binary_builtin_function = 433 + SnowflakeParserRULE_binary_or_ternary_builtin_function = 434 + SnowflakeParserRULE_ternary_builtin_function = 435 + SnowflakeParserRULE_pattern = 436 + SnowflakeParserRULE_column_name = 437 + SnowflakeParserRULE_column_list = 438 + SnowflakeParserRULE_object_name = 439 + SnowflakeParserRULE_num = 440 + SnowflakeParserRULE_expr_list = 441 + SnowflakeParserRULE_expr_list_sorted = 442 + SnowflakeParserRULE_expr = 443 + SnowflakeParserRULE_iff_expr = 444 + SnowflakeParserRULE_trim_expression = 445 + SnowflakeParserRULE_try_cast_expr = 446 + SnowflakeParserRULE_json_literal = 447 + SnowflakeParserRULE_kv_pair = 448 + SnowflakeParserRULE_value = 449 + SnowflakeParserRULE_arr_literal = 450 + SnowflakeParserRULE_data_type = 451 + SnowflakeParserRULE_primitive_expression = 452 + SnowflakeParserRULE_order_by_expr = 453 + SnowflakeParserRULE_asc_desc = 454 + SnowflakeParserRULE_over_clause = 455 + SnowflakeParserRULE_function_call = 456 + SnowflakeParserRULE_ranking_windowed_function = 457 + SnowflakeParserRULE_aggregate_function = 458 + SnowflakeParserRULE_literal = 459 + SnowflakeParserRULE_sign = 460 + SnowflakeParserRULE_full_column_name = 461 + SnowflakeParserRULE_bracket_expression = 462 + SnowflakeParserRULE_case_expression = 463 + SnowflakeParserRULE_switch_search_condition_section = 464 + SnowflakeParserRULE_switch_section = 465 + SnowflakeParserRULE_query_statement = 466 + SnowflakeParserRULE_with_expression = 467 + SnowflakeParserRULE_common_table_expression = 468 + SnowflakeParserRULE_anchor_clause = 469 + SnowflakeParserRULE_recursive_clause = 470 + SnowflakeParserRULE_select_statement = 471 + SnowflakeParserRULE_set_operators = 472 + SnowflakeParserRULE_select_optional_clauses = 473 + SnowflakeParserRULE_select_clause = 474 + SnowflakeParserRULE_select_top_clause = 475 + SnowflakeParserRULE_select_list_no_top = 476 + SnowflakeParserRULE_select_list_top = 477 + SnowflakeParserRULE_select_list = 478 + SnowflakeParserRULE_select_list_elem = 479 + SnowflakeParserRULE_column_elem = 480 + SnowflakeParserRULE_as_alias = 481 + SnowflakeParserRULE_expression_elem = 482 + SnowflakeParserRULE_column_position = 483 + SnowflakeParserRULE_all_distinct = 484 + SnowflakeParserRULE_top_clause = 485 + SnowflakeParserRULE_into_clause = 486 + SnowflakeParserRULE_var_list = 487 + SnowflakeParserRULE_var = 488 + SnowflakeParserRULE_from_clause = 489 + SnowflakeParserRULE_table_sources = 490 + SnowflakeParserRULE_table_source = 491 + SnowflakeParserRULE_table_source_item_joined = 492 + SnowflakeParserRULE_object_ref = 493 + SnowflakeParserRULE_flatten_table_option = 494 + SnowflakeParserRULE_flatten_table = 495 + SnowflakeParserRULE_prior_list = 496 + SnowflakeParserRULE_prior_item = 497 + SnowflakeParserRULE_outer_join = 498 + SnowflakeParserRULE_join_type = 499 + SnowflakeParserRULE_join_clause = 500 + SnowflakeParserRULE_at_before = 501 + SnowflakeParserRULE_end = 502 + SnowflakeParserRULE_changes = 503 + SnowflakeParserRULE_default_append_only = 504 + SnowflakeParserRULE_partition_by = 505 + SnowflakeParserRULE_alias = 506 + SnowflakeParserRULE_expr_alias_list = 507 + SnowflakeParserRULE_measures = 508 + SnowflakeParserRULE_match_opts = 509 + SnowflakeParserRULE_row_match = 510 + SnowflakeParserRULE_first_last = 511 + SnowflakeParserRULE_symbol = 512 + SnowflakeParserRULE_after_match = 513 + SnowflakeParserRULE_symbol_list = 514 + SnowflakeParserRULE_define = 515 + SnowflakeParserRULE_match_recognize = 516 + SnowflakeParserRULE_pivot_unpivot = 517 + SnowflakeParserRULE_column_alias_list_in_brackets = 518 + SnowflakeParserRULE_expr_list_in_parentheses = 519 + SnowflakeParserRULE_values = 520 + SnowflakeParserRULE_sample_method = 521 + SnowflakeParserRULE_repeatable_seed = 522 + SnowflakeParserRULE_sample_opts = 523 + SnowflakeParserRULE_sample = 524 + SnowflakeParserRULE_search_condition = 525 + SnowflakeParserRULE_comparison_operator = 526 + SnowflakeParserRULE_null_not_null = 527 + SnowflakeParserRULE_subquery = 528 + SnowflakeParserRULE_predicate = 529 + SnowflakeParserRULE_where_clause = 530 + SnowflakeParserRULE_group_item = 531 + SnowflakeParserRULE_group_by_clause = 532 + SnowflakeParserRULE_having_clause = 533 + SnowflakeParserRULE_qualify_clause = 534 + SnowflakeParserRULE_order_item = 535 + SnowflakeParserRULE_order_by_clause = 536 + SnowflakeParserRULE_row_rows = 537 + SnowflakeParserRULE_first_next = 538 + SnowflakeParserRULE_limit_clause = 539 + SnowflakeParserRULE_supplement_non_reserved_words = 540 +) + +// ISnowflake_fileContext is an interface to support dynamic dispatch. +type ISnowflake_fileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EOF() antlr.TerminalNode + AllBatch() []IBatchContext + Batch(i int) IBatchContext + AllSEMI() []antlr.TerminalNode + SEMI(i int) antlr.TerminalNode + + // IsSnowflake_fileContext differentiates from other interfaces. + IsSnowflake_fileContext() +} + +type Snowflake_fileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySnowflake_fileContext() *Snowflake_fileContext { + var p = new(Snowflake_fileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_snowflake_file + return p +} + +func InitEmptySnowflake_fileContext(p *Snowflake_fileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_snowflake_file +} + +func (*Snowflake_fileContext) IsSnowflake_fileContext() {} + +func NewSnowflake_fileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Snowflake_fileContext { + var p = new(Snowflake_fileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_snowflake_file + + return p +} + +func (s *Snowflake_fileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Snowflake_fileContext) EOF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEOF, 0) +} + +func (s *Snowflake_fileContext) AllBatch() []IBatchContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBatchContext); ok { + len++ + } + } + + tst := make([]IBatchContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBatchContext); ok { + tst[i] = t.(IBatchContext) + i++ + } + } + + return tst +} + +func (s *Snowflake_fileContext) Batch(i int) IBatchContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBatchContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBatchContext) +} + +func (s *Snowflake_fileContext) AllSEMI() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserSEMI) +} + +func (s *Snowflake_fileContext) SEMI(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEMI, i) +} + +func (s *Snowflake_fileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Snowflake_fileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Snowflake_fileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSnowflake_file(s) + } +} + +func (s *Snowflake_fileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSnowflake_file(s) + } +} + +func (s *Snowflake_fileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSnowflake_file(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Snowflake_file() (localctx ISnowflake_fileContext) { + localctx = NewSnowflake_fileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, SnowflakeParserRULE_snowflake_file) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(1093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserADD || _la == SnowflakeParserALTER || ((int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&844424930131969) != 0) || ((int64((_la-185)) & ^0x3f) == 0 && ((int64(1)<<(_la-185))&3518437208883233) != 0) || ((int64((_la-249)) & ^0x3f) == 0 && ((int64(1)<<(_la-249))&1108101562369) != 0) || ((int64((_la-343)) & ^0x3f) == 0 && ((int64(1)<<(_la-343))&140737488355361) != 0) || _la == SnowflakeParserLIST || _la == SnowflakeParserMERGE || _la == SnowflakeParserPUT || _la == SnowflakeParserREMOVE || ((int64((_la-714)) & ^0x3f) == 0 && ((int64(1)<<(_la-714))&576460752303423553) != 0) || _la == SnowflakeParserSET || _la == SnowflakeParserSHOW || ((int64((_la-945)) & ^0x3f) == 0 && ((int64(1)<<(_la-945))&142271053825) != 0) || _la == SnowflakeParserWITH { + { + p.SetState(1082) + p.Batch() + } + p.SetState(1087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(1083) + p.Match(SnowflakeParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1084) + p.Batch() + } + + } + p.SetState(1089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(1091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSEMI { + { + p.SetState(1090) + p.Match(SnowflakeParserSEMI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + { + p.SetState(1095) + p.Match(SnowflakeParserEOF) + 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 +} + +// IBatchContext is an interface to support dynamic dispatch. +type IBatchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_command() ISql_commandContext + + // IsBatchContext differentiates from other interfaces. + IsBatchContext() +} + +type BatchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBatchContext() *BatchContext { + var p = new(BatchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_batch + return p +} + +func InitEmptyBatchContext(p *BatchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_batch +} + +func (*BatchContext) IsBatchContext() {} + +func NewBatchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BatchContext { + var p = new(BatchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_batch + + return p +} + +func (s *BatchContext) GetParser() antlr.Parser { return s.parser } + +func (s *BatchContext) Sql_command() ISql_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_commandContext) +} + +func (s *BatchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BatchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BatchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterBatch(s) + } +} + +func (s *BatchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitBatch(s) + } +} + +func (s *BatchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitBatch(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Batch() (localctx IBatchContext) { + localctx = NewBatchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, SnowflakeParserRULE_batch) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1097) + p.Sql_command() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_commandContext is an interface to support dynamic dispatch. +type ISql_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Ddl_command() IDdl_commandContext + Dml_command() IDml_commandContext + Show_command() IShow_commandContext + Use_command() IUse_commandContext + Describe_command() IDescribe_commandContext + Other_command() IOther_commandContext + + // IsSql_commandContext differentiates from other interfaces. + IsSql_commandContext() +} + +type Sql_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_commandContext() *Sql_commandContext { + var p = new(Sql_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sql_command + return p +} + +func InitEmptySql_commandContext(p *Sql_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sql_command +} + +func (*Sql_commandContext) IsSql_commandContext() {} + +func NewSql_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_commandContext { + var p = new(Sql_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_sql_command + + return p +} + +func (s *Sql_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_commandContext) Ddl_command() IDdl_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDdl_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDdl_commandContext) +} + +func (s *Sql_commandContext) Dml_command() IDml_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_commandContext) +} + +func (s *Sql_commandContext) Show_command() IShow_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_commandContext) +} + +func (s *Sql_commandContext) Use_command() IUse_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_commandContext) +} + +func (s *Sql_commandContext) Describe_command() IDescribe_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_commandContext) +} + +func (s *Sql_commandContext) Other_command() IOther_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOther_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOther_commandContext) +} + +func (s *Sql_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSql_command(s) + } +} + +func (s *Sql_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSql_command(s) + } +} + +func (s *Sql_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSql_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Sql_command() (localctx ISql_commandContext) { + localctx = NewSql_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, SnowflakeParserRULE_sql_command) + p.SetState(1105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD, SnowflakeParserALTER, SnowflakeParserCREATE, SnowflakeParserDROP, SnowflakeParserUNDROP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1099) + p.Ddl_command() + } + + case SnowflakeParserDELETE, SnowflakeParserINSERT, SnowflakeParserMERGE, SnowflakeParserSELECT, SnowflakeParserUPDATE, SnowflakeParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1100) + p.Dml_command() + } + + case SnowflakeParserSHOW: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1101) + p.Show_command() + } + + case SnowflakeParserUSE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1102) + p.Use_command() + } + + case SnowflakeParserDESC, SnowflakeParserDESCRIBE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1103) + p.Describe_command() + } + + case SnowflakeParserCALL, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOPY, SnowflakeParserEXECUTE, SnowflakeParserEXPLAIN, SnowflakeParserGET, SnowflakeParserGRANT, SnowflakeParserLIST, SnowflakeParserPUT, SnowflakeParserREMOVE, SnowflakeParserREVOKE, SnowflakeParserROLLBACK, SnowflakeParserSET, SnowflakeParserTRUNCATE, SnowflakeParserUNSET: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1104) + p.Other_command() + } + + 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 +} + +// IDdl_commandContext is an interface to support dynamic dispatch. +type IDdl_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_command() IAlter_commandContext + Create_command() ICreate_commandContext + Drop_command() IDrop_commandContext + Undrop_command() IUndrop_commandContext + + // IsDdl_commandContext differentiates from other interfaces. + IsDdl_commandContext() +} + +type Ddl_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDdl_commandContext() *Ddl_commandContext { + var p = new(Ddl_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ddl_command + return p +} + +func InitEmptyDdl_commandContext(p *Ddl_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ddl_command +} + +func (*Ddl_commandContext) IsDdl_commandContext() {} + +func NewDdl_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ddl_commandContext { + var p = new(Ddl_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_ddl_command + + return p +} + +func (s *Ddl_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ddl_commandContext) Alter_command() IAlter_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_commandContext) +} + +func (s *Ddl_commandContext) Create_command() ICreate_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_commandContext) +} + +func (s *Ddl_commandContext) Drop_command() IDrop_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_commandContext) +} + +func (s *Ddl_commandContext) Undrop_command() IUndrop_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_commandContext) +} + +func (s *Ddl_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ddl_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ddl_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDdl_command(s) + } +} + +func (s *Ddl_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDdl_command(s) + } +} + +func (s *Ddl_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDdl_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Ddl_command() (localctx IDdl_commandContext) { + localctx = NewDdl_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, SnowflakeParserRULE_ddl_command) + p.SetState(1111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD, SnowflakeParserALTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1107) + p.Alter_command() + } + + case SnowflakeParserCREATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1108) + p.Create_command() + } + + case SnowflakeParserDROP: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1109) + p.Drop_command() + } + + case SnowflakeParserUNDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1110) + p.Undrop_command() + } + + 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 +} + +// IDml_commandContext is an interface to support dynamic dispatch. +type IDml_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_statement() IQuery_statementContext + Insert_statement() IInsert_statementContext + Insert_multi_table_statement() IInsert_multi_table_statementContext + Update_statement() IUpdate_statementContext + Delete_statement() IDelete_statementContext + Merge_statement() IMerge_statementContext + + // IsDml_commandContext differentiates from other interfaces. + IsDml_commandContext() +} + +type Dml_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_commandContext() *Dml_commandContext { + var p = new(Dml_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_dml_command + return p +} + +func InitEmptyDml_commandContext(p *Dml_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_dml_command +} + +func (*Dml_commandContext) IsDml_commandContext() {} + +func NewDml_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_commandContext { + var p = new(Dml_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_dml_command + + return p +} + +func (s *Dml_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_commandContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *Dml_commandContext) Insert_statement() IInsert_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_statementContext) +} + +func (s *Dml_commandContext) Insert_multi_table_statement() IInsert_multi_table_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_multi_table_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_multi_table_statementContext) +} + +func (s *Dml_commandContext) Update_statement() IUpdate_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_statementContext) +} + +func (s *Dml_commandContext) Delete_statement() IDelete_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_statementContext) +} + +func (s *Dml_commandContext) Merge_statement() IMerge_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_statementContext) +} + +func (s *Dml_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDml_command(s) + } +} + +func (s *Dml_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDml_command(s) + } +} + +func (s *Dml_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDml_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Dml_command() (localctx IDml_commandContext) { + localctx = NewDml_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, SnowflakeParserRULE_dml_command) + p.SetState(1119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 5, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1113) + p.Query_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1114) + p.Insert_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1115) + p.Insert_multi_table_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1116) + p.Update_statement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1117) + p.Delete_statement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1118) + p.Merge_statement() + } + + 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 +} + +// IInsert_statementContext is an interface to support dynamic dispatch. +type IInsert_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + INTO() antlr.TerminalNode + Object_name() IObject_nameContext + Values_builder() IValues_builderContext + Select_statement() ISelect_statementContext + OVERWRITE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_list() IColumn_listContext + RR_BRACKET() antlr.TerminalNode + + // IsInsert_statementContext differentiates from other interfaces. + IsInsert_statementContext() +} + +type Insert_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_statementContext() *Insert_statementContext { + var p = new(Insert_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_insert_statement + return p +} + +func InitEmptyInsert_statementContext(p *Insert_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_insert_statement +} + +func (*Insert_statementContext) IsInsert_statementContext() {} + +func NewInsert_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_statementContext { + var p = new(Insert_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_insert_statement + + return p +} + +func (s *Insert_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_statementContext) INSERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINSERT, 0) +} + +func (s *Insert_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTO, 0) +} + +func (s *Insert_statementContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Insert_statementContext) Values_builder() IValues_builderContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_builderContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_builderContext) +} + +func (s *Insert_statementContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Insert_statementContext) OVERWRITE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOVERWRITE, 0) +} + +func (s *Insert_statementContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Insert_statementContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Insert_statementContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Insert_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterInsert_statement(s) + } +} + +func (s *Insert_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitInsert_statement(s) + } +} + +func (s *Insert_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitInsert_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Insert_statement() (localctx IInsert_statementContext) { + localctx = NewInsert_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, SnowflakeParserRULE_insert_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1121) + p.Match(SnowflakeParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOVERWRITE { + { + p.SetState(1122) + p.Match(SnowflakeParserOVERWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1125) + p.Match(SnowflakeParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1126) + p.Object_name() + } + p.SetState(1131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(1127) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1128) + p.Column_list() + } + { + p.SetState(1129) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserVALUES: + { + p.SetState(1133) + p.Values_builder() + } + + case SnowflakeParserSELECT: + { + p.SetState(1134) + p.Select_statement() + } + + 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 +} + +// IInsert_multi_table_statementContext is an interface to support dynamic dispatch. +type IInsert_multi_table_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + ALL() antlr.TerminalNode + AllInto_clause2() []IInto_clause2Context + Into_clause2(i int) IInto_clause2Context + OVERWRITE() antlr.TerminalNode + Subquery() ISubqueryContext + FIRST() antlr.TerminalNode + AllWHEN() []antlr.TerminalNode + WHEN(i int) antlr.TerminalNode + AllPredicate() []IPredicateContext + Predicate(i int) IPredicateContext + AllTHEN() []antlr.TerminalNode + THEN(i int) antlr.TerminalNode + ELSE() antlr.TerminalNode + + // IsInsert_multi_table_statementContext differentiates from other interfaces. + IsInsert_multi_table_statementContext() +} + +type Insert_multi_table_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_multi_table_statementContext() *Insert_multi_table_statementContext { + var p = new(Insert_multi_table_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_insert_multi_table_statement + return p +} + +func InitEmptyInsert_multi_table_statementContext(p *Insert_multi_table_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_insert_multi_table_statement +} + +func (*Insert_multi_table_statementContext) IsInsert_multi_table_statementContext() {} + +func NewInsert_multi_table_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_multi_table_statementContext { + var p = new(Insert_multi_table_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_insert_multi_table_statement + + return p +} + +func (s *Insert_multi_table_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_multi_table_statementContext) INSERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINSERT, 0) +} + +func (s *Insert_multi_table_statementContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Insert_multi_table_statementContext) AllInto_clause2() []IInto_clause2Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInto_clause2Context); ok { + len++ + } + } + + tst := make([]IInto_clause2Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInto_clause2Context); ok { + tst[i] = t.(IInto_clause2Context) + i++ + } + } + + return tst +} + +func (s *Insert_multi_table_statementContext) Into_clause2(i int) IInto_clause2Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clause2Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInto_clause2Context) +} + +func (s *Insert_multi_table_statementContext) OVERWRITE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOVERWRITE, 0) +} + +func (s *Insert_multi_table_statementContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Insert_multi_table_statementContext) FIRST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIRST, 0) +} + +func (s *Insert_multi_table_statementContext) AllWHEN() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserWHEN) +} + +func (s *Insert_multi_table_statementContext) WHEN(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHEN, i) +} + +func (s *Insert_multi_table_statementContext) AllPredicate() []IPredicateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPredicateContext); ok { + len++ + } + } + + tst := make([]IPredicateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPredicateContext); ok { + tst[i] = t.(IPredicateContext) + i++ + } + } + + return tst +} + +func (s *Insert_multi_table_statementContext) Predicate(i int) IPredicateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *Insert_multi_table_statementContext) AllTHEN() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserTHEN) +} + +func (s *Insert_multi_table_statementContext) THEN(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserTHEN, i) +} + +func (s *Insert_multi_table_statementContext) ELSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserELSE, 0) +} + +func (s *Insert_multi_table_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_multi_table_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_multi_table_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterInsert_multi_table_statement(s) + } +} + +func (s *Insert_multi_table_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitInsert_multi_table_statement(s) + } +} + +func (s *Insert_multi_table_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitInsert_multi_table_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Insert_multi_table_statement() (localctx IInsert_multi_table_statementContext) { + localctx = NewInsert_multi_table_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, SnowflakeParserRULE_insert_multi_table_statement) + var _la int + + p.SetState(1166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1137) + p.Match(SnowflakeParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOVERWRITE { + { + p.SetState(1138) + p.Match(SnowflakeParserOVERWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1141) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1142) + p.Into_clause2() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1143) + p.Match(SnowflakeParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOVERWRITE { + { + p.SetState(1144) + p.Match(SnowflakeParserOVERWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1147) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserALL || _la == SnowflakeParserFIRST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserWHEN { + { + p.SetState(1148) + p.Match(SnowflakeParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1149) + p.Predicate() + } + { + p.SetState(1150) + p.Match(SnowflakeParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserINTO { + { + p.SetState(1151) + p.Into_clause2() + } + + p.SetState(1154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + p.SetState(1158) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(1162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserELSE { + { + p.SetState(1160) + p.Match(SnowflakeParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1161) + p.Into_clause2() + } + + } + { + p.SetState(1164) + p.Subquery() + } + + 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 +} + +// IInto_clause2Context is an interface to support dynamic dispatch. +type IInto_clause2Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + Object_name() IObject_nameContext + LR_BRACKET() antlr.TerminalNode + Column_list() IColumn_listContext + RR_BRACKET() antlr.TerminalNode + Values_list() IValues_listContext + + // IsInto_clause2Context differentiates from other interfaces. + IsInto_clause2Context() +} + +type Into_clause2Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInto_clause2Context() *Into_clause2Context { + var p = new(Into_clause2Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_into_clause2 + return p +} + +func InitEmptyInto_clause2Context(p *Into_clause2Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_into_clause2 +} + +func (*Into_clause2Context) IsInto_clause2Context() {} + +func NewInto_clause2Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_clause2Context { + var p = new(Into_clause2Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_into_clause2 + + return p +} + +func (s *Into_clause2Context) GetParser() antlr.Parser { return s.parser } + +func (s *Into_clause2Context) INTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTO, 0) +} + +func (s *Into_clause2Context) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Into_clause2Context) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Into_clause2Context) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Into_clause2Context) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Into_clause2Context) Values_list() IValues_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_listContext) +} + +func (s *Into_clause2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Into_clause2Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Into_clause2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterInto_clause2(s) + } +} + +func (s *Into_clause2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitInto_clause2(s) + } +} + +func (s *Into_clause2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitInto_clause2(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Into_clause2() (localctx IInto_clause2Context) { + localctx = NewInto_clause2Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, SnowflakeParserRULE_into_clause2) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1168) + p.Match(SnowflakeParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1169) + p.Object_name() + } + p.SetState(1174) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(1170) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1171) + p.Column_list() + } + { + p.SetState(1172) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserVALUES { + { + p.SetState(1176) + p.Values_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 +} + +// IValues_listContext is an interface to support dynamic dispatch. +type IValues_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllValue_item() []IValue_itemContext + Value_item(i int) IValue_itemContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsValues_listContext differentiates from other interfaces. + IsValues_listContext() +} + +type Values_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValues_listContext() *Values_listContext { + var p = new(Values_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_values_list + return p +} + +func InitEmptyValues_listContext(p *Values_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_values_list +} + +func (*Values_listContext) IsValues_listContext() {} + +func NewValues_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Values_listContext { + var p = new(Values_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_values_list + + return p +} + +func (s *Values_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Values_listContext) VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALUES, 0) +} + +func (s *Values_listContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Values_listContext) AllValue_item() []IValue_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IValue_itemContext); ok { + len++ + } + } + + tst := make([]IValue_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IValue_itemContext); ok { + tst[i] = t.(IValue_itemContext) + i++ + } + } + + return tst +} + +func (s *Values_listContext) Value_item(i int) IValue_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValue_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IValue_itemContext) +} + +func (s *Values_listContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Values_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Values_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Values_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Values_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Values_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterValues_list(s) + } +} + +func (s *Values_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitValues_list(s) + } +} + +func (s *Values_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitValues_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Values_list() (localctx IValues_listContext) { + localctx = NewValues_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, SnowflakeParserRULE_values_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1179) + p.Match(SnowflakeParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1180) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1181) + p.Value_item() + } + p.SetState(1186) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1182) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1183) + p.Value_item() + } + + p.SetState(1188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1189) + p.Match(SnowflakeParserRR_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 +} + +// IValue_itemContext is an interface to support dynamic dispatch. +type IValue_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + DEFAULT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsValue_itemContext differentiates from other interfaces. + IsValue_itemContext() +} + +type Value_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValue_itemContext() *Value_itemContext { + var p = new(Value_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_value_item + return p +} + +func InitEmptyValue_itemContext(p *Value_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_value_item +} + +func (*Value_itemContext) IsValue_itemContext() {} + +func NewValue_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Value_itemContext { + var p = new(Value_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_value_item + + return p +} + +func (s *Value_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Value_itemContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Value_itemContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT, 0) +} + +func (s *Value_itemContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Value_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Value_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Value_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterValue_item(s) + } +} + +func (s *Value_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitValue_item(s) + } +} + +func (s *Value_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitValue_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Value_item() (localctx IValue_itemContext) { + localctx = NewValue_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, SnowflakeParserRULE_value_item) + p.SetState(1194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1191) + p.Column_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1192) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1193) + p.Match(SnowflakeParserNULL_) + 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 +} + +// IMerge_statementContext is an interface to support dynamic dispatch. +type IMerge_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MERGE() antlr.TerminalNode + INTO() antlr.TerminalNode + Object_name() IObject_nameContext + USING() antlr.TerminalNode + Table_source() ITable_sourceContext + ON() antlr.TerminalNode + Search_condition() ISearch_conditionContext + Merge_matches() IMerge_matchesContext + + // IsMerge_statementContext differentiates from other interfaces. + IsMerge_statementContext() +} + +type Merge_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_statementContext() *Merge_statementContext { + var p = new(Merge_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_merge_statement + return p +} + +func InitEmptyMerge_statementContext(p *Merge_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_merge_statement +} + +func (*Merge_statementContext) IsMerge_statementContext() {} + +func NewMerge_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_statementContext { + var p = new(Merge_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_merge_statement + + return p +} + +func (s *Merge_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_statementContext) MERGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMERGE, 0) +} + +func (s *Merge_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTO, 0) +} + +func (s *Merge_statementContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Merge_statementContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *Merge_statementContext) Table_source() ITable_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourceContext) +} + +func (s *Merge_statementContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Merge_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Merge_statementContext) Merge_matches() IMerge_matchesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_matchesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_matchesContext) +} + +func (s *Merge_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterMerge_statement(s) + } +} + +func (s *Merge_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitMerge_statement(s) + } +} + +func (s *Merge_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitMerge_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Merge_statement() (localctx IMerge_statementContext) { + localctx = NewMerge_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, SnowflakeParserRULE_merge_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1196) + p.Match(SnowflakeParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1197) + p.Match(SnowflakeParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1198) + p.Object_name() + } + { + p.SetState(1199) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1200) + p.Table_source() + } + { + p.SetState(1201) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1202) + p.search_condition(0) + } + { + p.SetState(1203) + p.Merge_matches() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_matchesContext is an interface to support dynamic dispatch. +type IMerge_matchesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + MATCHED() antlr.TerminalNode + THEN() antlr.TerminalNode + Merge_update_delete() IMerge_update_deleteContext + AND() antlr.TerminalNode + Search_condition() ISearch_conditionContext + NOT() antlr.TerminalNode + Merge_insert() IMerge_insertContext + + // IsMerge_matchesContext differentiates from other interfaces. + IsMerge_matchesContext() +} + +type Merge_matchesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_matchesContext() *Merge_matchesContext { + var p = new(Merge_matchesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_merge_matches + return p +} + +func InitEmptyMerge_matchesContext(p *Merge_matchesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_merge_matches +} + +func (*Merge_matchesContext) IsMerge_matchesContext() {} + +func NewMerge_matchesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_matchesContext { + var p = new(Merge_matchesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_merge_matches + + return p +} + +func (s *Merge_matchesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_matchesContext) WHEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHEN, 0) +} + +func (s *Merge_matchesContext) MATCHED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCHED, 0) +} + +func (s *Merge_matchesContext) THEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTHEN, 0) +} + +func (s *Merge_matchesContext) Merge_update_delete() IMerge_update_deleteContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_update_deleteContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_update_deleteContext) +} + +func (s *Merge_matchesContext) AND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAND, 0) +} + +func (s *Merge_matchesContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Merge_matchesContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *Merge_matchesContext) Merge_insert() IMerge_insertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_insertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_insertContext) +} + +func (s *Merge_matchesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_matchesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_matchesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterMerge_matches(s) + } +} + +func (s *Merge_matchesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitMerge_matches(s) + } +} + +func (s *Merge_matchesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitMerge_matches(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Merge_matches() (localctx IMerge_matchesContext) { + localctx = NewMerge_matchesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, SnowflakeParserRULE_merge_matches) + var _la int + + p.SetState(1222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 21, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1205) + p.Match(SnowflakeParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1206) + p.Match(SnowflakeParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1209) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAND { + { + p.SetState(1207) + p.Match(SnowflakeParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1208) + p.search_condition(0) + } + + } + { + p.SetState(1211) + p.Match(SnowflakeParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1212) + p.Merge_update_delete() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1213) + p.Match(SnowflakeParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1214) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1215) + p.Match(SnowflakeParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1218) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAND { + { + p.SetState(1216) + p.Match(SnowflakeParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1217) + p.search_condition(0) + } + + } + { + p.SetState(1220) + p.Match(SnowflakeParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1221) + p.Merge_insert() + } + + 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 +} + +// IMerge_update_deleteContext is an interface to support dynamic dispatch. +type IMerge_update_deleteContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + Alias() IAliasContext + DOT() antlr.TerminalNode + DELETE() antlr.TerminalNode + + // IsMerge_update_deleteContext differentiates from other interfaces. + IsMerge_update_deleteContext() +} + +type Merge_update_deleteContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_update_deleteContext() *Merge_update_deleteContext { + var p = new(Merge_update_deleteContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_merge_update_delete + return p +} + +func InitEmptyMerge_update_deleteContext(p *Merge_update_deleteContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_merge_update_delete +} + +func (*Merge_update_deleteContext) IsMerge_update_deleteContext() {} + +func NewMerge_update_deleteContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_update_deleteContext { + var p = new(Merge_update_deleteContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_merge_update_delete + + return p +} + +func (s *Merge_update_deleteContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_update_deleteContext) UPDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUPDATE, 0) +} + +func (s *Merge_update_deleteContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Merge_update_deleteContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Merge_update_deleteContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Merge_update_deleteContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Merge_update_deleteContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Merge_update_deleteContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Merge_update_deleteContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Merge_update_deleteContext) Alias() IAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAliasContext) +} + +func (s *Merge_update_deleteContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *Merge_update_deleteContext) DELETE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELETE, 0) +} + +func (s *Merge_update_deleteContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_update_deleteContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_update_deleteContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterMerge_update_delete(s) + } +} + +func (s *Merge_update_deleteContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitMerge_update_delete(s) + } +} + +func (s *Merge_update_deleteContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitMerge_update_delete(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Merge_update_delete() (localctx IMerge_update_deleteContext) { + localctx = NewMerge_update_deleteContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, SnowflakeParserRULE_merge_update_delete) + var _la int + + p.SetState(1244) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserUPDATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1224) + p.Match(SnowflakeParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1225) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1229) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 22, p.GetParserRuleContext()) == 1 { + { + p.SetState(1226) + p.Alias() + } + { + p.SetState(1227) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1231) + p.Column_name() + } + { + p.SetState(1232) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1233) + p.expr(0) + } + p.SetState(1240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(1234) + p.Column_name() + } + { + p.SetState(1235) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1236) + p.expr(0) + } + + p.SetState(1242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case SnowflakeParserDELETE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1243) + p.Match(SnowflakeParserDELETE) + 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 +} + +// IMerge_insertContext is an interface to support dynamic dispatch. +type IMerge_insertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT() antlr.TerminalNode + VALUES() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Expr_list() IExpr_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Column_list() IColumn_listContext + + // IsMerge_insertContext differentiates from other interfaces. + IsMerge_insertContext() +} + +type Merge_insertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_insertContext() *Merge_insertContext { + var p = new(Merge_insertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_merge_insert + return p +} + +func InitEmptyMerge_insertContext(p *Merge_insertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_merge_insert +} + +func (*Merge_insertContext) IsMerge_insertContext() {} + +func NewMerge_insertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_insertContext { + var p = new(Merge_insertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_merge_insert + + return p +} + +func (s *Merge_insertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_insertContext) INSERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINSERT, 0) +} + +func (s *Merge_insertContext) VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALUES, 0) +} + +func (s *Merge_insertContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Merge_insertContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Merge_insertContext) 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 *Merge_insertContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Merge_insertContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Merge_insertContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Merge_insertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_insertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_insertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterMerge_insert(s) + } +} + +func (s *Merge_insertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitMerge_insert(s) + } +} + +func (s *Merge_insertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitMerge_insert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Merge_insert() (localctx IMerge_insertContext) { + localctx = NewMerge_insertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, SnowflakeParserRULE_merge_insert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1246) + p.Match(SnowflakeParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(1247) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1248) + p.Column_list() + } + { + p.SetState(1249) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(1253) + p.Match(SnowflakeParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1254) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1255) + p.Expr_list() + } + { + p.SetState(1256) + p.Match(SnowflakeParserRR_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 +} + +// IUpdate_statementContext is an interface to support dynamic dispatch. +type IUpdate_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE() antlr.TerminalNode + Object_name() IObject_nameContext + SET() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + FROM() antlr.TerminalNode + Table_sources() ITable_sourcesContext + WHERE() antlr.TerminalNode + Search_condition() ISearch_conditionContext + + // IsUpdate_statementContext differentiates from other interfaces. + IsUpdate_statementContext() +} + +type Update_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_statementContext() *Update_statementContext { + var p = new(Update_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_update_statement + return p +} + +func InitEmptyUpdate_statementContext(p *Update_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_update_statement +} + +func (*Update_statementContext) IsUpdate_statementContext() {} + +func NewUpdate_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_statementContext { + var p = new(Update_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_update_statement + + return p +} + +func (s *Update_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_statementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUPDATE, 0) +} + +func (s *Update_statementContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Update_statementContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Update_statementContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Update_statementContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Update_statementContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Update_statementContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Update_statementContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Update_statementContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Update_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Update_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Update_statementContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Update_statementContext) Table_sources() ITable_sourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourcesContext) +} + +func (s *Update_statementContext) WHERE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHERE, 0) +} + +func (s *Update_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Update_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUpdate_statement(s) + } +} + +func (s *Update_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUpdate_statement(s) + } +} + +func (s *Update_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUpdate_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Update_statement() (localctx IUpdate_statementContext) { + localctx = NewUpdate_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, SnowflakeParserRULE_update_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1258) + p.Match(SnowflakeParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1259) + p.Object_name() + } + { + p.SetState(1260) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1261) + p.Column_name() + } + { + p.SetState(1262) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1263) + p.expr(0) + } + p.SetState(1271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1264) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1265) + p.Column_name() + } + { + p.SetState(1266) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1267) + p.expr(0) + } + + p.SetState(1273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(1276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFROM { + { + p.SetState(1274) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1275) + p.Table_sources() + } + + } + p.SetState(1280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWHERE { + { + p.SetState(1278) + p.Match(SnowflakeParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1279) + p.search_condition(0) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_or_queryContext is an interface to support dynamic dispatch. +type ITable_or_queryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Object_name() IObject_nameContext + LR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + RR_BRACKET() antlr.TerminalNode + + // IsTable_or_queryContext differentiates from other interfaces. + IsTable_or_queryContext() +} + +type Table_or_queryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_or_queryContext() *Table_or_queryContext { + var p = new(Table_or_queryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_or_query + return p +} + +func InitEmptyTable_or_queryContext(p *Table_or_queryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_or_query +} + +func (*Table_or_queryContext) IsTable_or_queryContext() {} + +func NewTable_or_queryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_or_queryContext { + var p = new(Table_or_queryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_table_or_query + + return p +} + +func (s *Table_or_queryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_or_queryContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Table_or_queryContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Table_or_queryContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Table_or_queryContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Table_or_queryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_or_queryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_or_queryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTable_or_query(s) + } +} + +func (s *Table_or_queryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTable_or_query(s) + } +} + +func (s *Table_or_queryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTable_or_query(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Table_or_query() (localctx ITable_or_queryContext) { + localctx = NewTable_or_queryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, SnowflakeParserRULE_table_or_query) + p.SetState(1287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAAD_PROVISIONER_Q, SnowflakeParserABORT, SnowflakeParserABORT_AFTER_WAIT, SnowflakeParserABORT_DETACHED_QUERY, SnowflakeParserABORT_STATEMENT, SnowflakeParserABSENT, SnowflakeParserABSOLUTE, SnowflakeParserACCESS, SnowflakeParserACCOUNTADMIN, SnowflakeParserACCOUNTS, SnowflakeParserACTION, SnowflakeParserACTIVE, SnowflakeParserADD, SnowflakeParserADMINISTER, SnowflakeParserADMIN_NAME, SnowflakeParserADMIN_PASSWORD, SnowflakeParserAES, SnowflakeParserAFTER, SnowflakeParserAGGREGATE, SnowflakeParserALERT, SnowflakeParserALERTS, SnowflakeParserALLOWED, SnowflakeParserALLOWED_ACCOUNTS, SnowflakeParserALLOWED_DATABASES, SnowflakeParserALLOWED_INTEGRATION_TYPES, SnowflakeParserALLOWED_IP_LIST, SnowflakeParserALLOWED_SHARES, SnowflakeParserALLOWED_VALUES, SnowflakeParserALLOW_CLIENT_MFA_CACHING, SnowflakeParserALLOW_CONNECTIONS, SnowflakeParserALLOW_DUPLICATE, SnowflakeParserALLOW_ID_TOKEN, SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, SnowflakeParserALLOW_OVERLAPPING_EXECUTION, SnowflakeParserALLOW_SINGLE_EVENT_LOSS, SnowflakeParserALWAYS, SnowflakeParserANONYMOUS, SnowflakeParserANSI_DEFAULTS, SnowflakeParserAPI, SnowflakeParserAPI_ALLOWED_PREFIXES, SnowflakeParserAPI_AWS_ROLE_ARN, SnowflakeParserAPI_BLOCKED_PREFIXES, SnowflakeParserAPI_INTEGRATION, SnowflakeParserAPI_KEY, SnowflakeParserAPI_PROVIDER, SnowflakeParserAPPEND, SnowflakeParserAPPEND_ONLY, SnowflakeParserAPPLICATION, SnowflakeParserAPPLY, SnowflakeParserAPP_NAME, SnowflakeParserASC, SnowflakeParserATTACH, SnowflakeParserAT_KEYWORD, SnowflakeParserAUTHORIZATION, SnowflakeParserAUTHORIZATIONS, SnowflakeParserAUTO, SnowflakeParserAUTO_Q, SnowflakeParserAUTOCOMMIT, SnowflakeParserAUTOCOMMIT_API_SUPPORTED, SnowflakeParserAUTOINCREMENT, SnowflakeParserAUTO_COMPRESS, SnowflakeParserAUTO_DETECT, SnowflakeParserAUTO_INGEST, SnowflakeParserAUTO_REFRESH, SnowflakeParserAUTO_RESUME, SnowflakeParserAUTO_SUSPEND, SnowflakeParserAVG, SnowflakeParserAVRO, SnowflakeParserAVRO_Q, SnowflakeParserAWS_KEY_ID, SnowflakeParserAWS_ROLE, SnowflakeParserAWS_SECRET_KEY, SnowflakeParserAWS_SNS, SnowflakeParserAWS_SNS_ROLE_ARN, SnowflakeParserAWS_SNS_TOPIC, SnowflakeParserAWS_SNS_TOPIC_ARN, SnowflakeParserAWS_TOKEN, SnowflakeParserAZURE, SnowflakeParserAZURE_AD_APPLICATION_ID, SnowflakeParserAZURE_EVENT_GRID, SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, SnowflakeParserAZURE_Q, SnowflakeParserAZURE_SAS_TOKEN, SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, SnowflakeParserAZURE_TENANT_ID, SnowflakeParserBEFORE, SnowflakeParserBEGIN, SnowflakeParserBERNOULLI, SnowflakeParserBINARY_AS_TEXT, SnowflakeParserBINARY_CHECKSUM, SnowflakeParserBINARY_FORMAT, SnowflakeParserBINARY_INPUT_FORMAT, SnowflakeParserBINARY_OUTPUT_FORMAT, SnowflakeParserBINDING, SnowflakeParserBLOCK, SnowflakeParserBLOCKED_IP_LIST, SnowflakeParserBLOCKED_ROLES_LIST, SnowflakeParserBODY, SnowflakeParserBOTH_Q, SnowflakeParserBROTLI, SnowflakeParserBUSINESS_CRITICAL, SnowflakeParserCACHE, SnowflakeParserCALL, SnowflakeParserCALLED, SnowflakeParserCALLER, SnowflakeParserCASCADE, SnowflakeParserCASE_INSENSITIVE, SnowflakeParserCASE_SENSITIVE, SnowflakeParserCATCH, SnowflakeParserCERTIFICATE, SnowflakeParserCHANGE, SnowflakeParserCHANGES, SnowflakeParserCHANGETABLE, SnowflakeParserCHANGE_RETENTION, SnowflakeParserCHANGE_TRACKING, SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserCHARINDEX, SnowflakeParserCHECKSUM, SnowflakeParserCHECKSUM_AGG, SnowflakeParserCHECK_EXPIRATION, SnowflakeParserCHECK_POLICY, SnowflakeParserCLASSIFIER_FUNCTION, SnowflakeParserCLEANUP, SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, SnowflakeParserCLIENT_MEMORY_LIMIT, SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, SnowflakeParserCLIENT_PREFETCH_THREADS, SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, SnowflakeParserCLONE, SnowflakeParserCLOSE, SnowflakeParserCLUSTER, SnowflakeParserCLUSTERED, SnowflakeParserCLUSTERING, SnowflakeParserCOALESCE, SnowflakeParserCOLLATE, SnowflakeParserCOLLECTION, SnowflakeParserCOLUMNS, SnowflakeParserCOL_LENGTH, SnowflakeParserCOL_NAME, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOMMITTED, SnowflakeParserCOMPRESS, SnowflakeParserCOMPRESSION, SnowflakeParserCONCAT, SnowflakeParserCONCAT_NULL_YIELDS_NULL, SnowflakeParserCONCAT_WS, SnowflakeParserCONDITION, SnowflakeParserCONFIGURATION, SnowflakeParserCONNECTIONS, SnowflakeParserCONTAINMENT, SnowflakeParserCONTAINS, SnowflakeParserCONTENT, SnowflakeParserCONTEXT, SnowflakeParserCONTEXT_HEADERS, SnowflakeParserCONTEXT_INFO, SnowflakeParserCONTINUE, SnowflakeParserCONTROL, SnowflakeParserCONVERSATION, SnowflakeParserCOOKIE, SnowflakeParserCOPY, SnowflakeParserCOPY_ONLY, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserCOUNT, SnowflakeParserCOUNT_BIG, SnowflakeParserCREDENTIALS, SnowflakeParserCREDIT_QUOTA, SnowflakeParserCSV, SnowflakeParserCSV_Q, SnowflakeParserCUBE, SnowflakeParserCUME_DIST, SnowflakeParserCURRENT_DATE, SnowflakeParserCURRENT_TIMESTAMP, SnowflakeParserCURSOR, SnowflakeParserCUSTOM, SnowflakeParserDAILY, SnowflakeParserDATA, SnowflakeParserDATABASES, SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, SnowflakeParserDATEADD, SnowflakeParserDATEDIFF, SnowflakeParserDATENAME, SnowflakeParserDATEPART, SnowflakeParserDATE_FORMAT, SnowflakeParserDATE_INPUT_FORMAT, SnowflakeParserDATE_OUTPUT_FORMAT, SnowflakeParserDATE_PART, SnowflakeParserDAYS, SnowflakeParserDAYS_TO_EXPIRY, SnowflakeParserDECLARE, SnowflakeParserDEFAULT, SnowflakeParserDEFAULT_DDL_COLLATION_, SnowflakeParserDEFAULT_NAMESPACE, SnowflakeParserDEFAULT_ROLE, SnowflakeParserDEFAULT_WAREHOUSE, SnowflakeParserDEFERRABLE, SnowflakeParserDEFERRED, SnowflakeParserDEFINE, SnowflakeParserDEFINITION, SnowflakeParserDEFLATE, SnowflakeParserDELEGATED, SnowflakeParserDELTA, SnowflakeParserDENSE_RANK, SnowflakeParserDESC, SnowflakeParserDESCRIBE, SnowflakeParserDIRECTION, SnowflakeParserDIRECTORY, SnowflakeParserDISABLE, SnowflakeParserDISABLED, SnowflakeParserDISABLE_AUTO_CONVERT, SnowflakeParserDISABLE_SNOWFLAKE_DATA, SnowflakeParserDISK, SnowflakeParserDISPLAY_NAME, SnowflakeParserDO, SnowflakeParserDOWNSTREAM, SnowflakeParserDOUBLE, SnowflakeParserDYNAMIC, SnowflakeParserECONOMY, SnowflakeParserEDITION, SnowflakeParserEMAIL, SnowflakeParserEMPTY_, SnowflakeParserEMPTY_FIELD_AS_NULL, SnowflakeParserENABLE, SnowflakeParserENABLED, SnowflakeParserENABLE_FOR_PRIVILEGE, SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, SnowflakeParserENABLE_OCTAL, SnowflakeParserENABLE_QUERY_ACCELERATION, SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, SnowflakeParserENCODING, SnowflakeParserENCRYPTION, SnowflakeParserEND, SnowflakeParserENDPOINT, SnowflakeParserEND_TIMESTAMP, SnowflakeParserENFORCED, SnowflakeParserENFORCE_LENGTH, SnowflakeParserENFORCE_SESSION_POLICY, SnowflakeParserENTERPRISE, SnowflakeParserEQUALITY, SnowflakeParserERROR_INTEGRATION, SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, SnowflakeParserESCAPE, SnowflakeParserESCAPE_UNENCLOSED_FIELD, SnowflakeParserEXCEPT, SnowflakeParserEXCHANGE, SnowflakeParserEXECUTE, SnowflakeParserEXECUTION, SnowflakeParserEXIST, SnowflakeParserEXIT, SnowflakeParserEXPAND, SnowflakeParserEXPIRY_DATE, SnowflakeParserEXPLAIN, SnowflakeParserEXPLICIT, SnowflakeParserEXTERNAL, SnowflakeParserEXTERNAL_OAUTH, SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ISSUER, SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, SnowflakeParserEXTERNAL_OAUTH_TYPE, SnowflakeParserEXTERNAL_STAGE, SnowflakeParserFAILOVER, SnowflakeParserFAILOVER_MODE, SnowflakeParserFAIL_OPERATION, SnowflakeParserFETCH, SnowflakeParserFIELD_DELIMITER, SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, SnowflakeParserFILE, SnowflakeParserFILES, SnowflakeParserFILE_EXTENSION, SnowflakeParserFILE_FORMAT, SnowflakeParserFILTER, SnowflakeParserFIRST, SnowflakeParserFIRST_NAME, SnowflakeParserFLATTEN, SnowflakeParserFORCE, SnowflakeParserFOREIGN, SnowflakeParserFORMAT, SnowflakeParserFORMATS, SnowflakeParserFORMAT_NAME, SnowflakeParserFREQUENCY, SnowflakeParserFUNCTION, SnowflakeParserFUNCTIONS, SnowflakeParserFUTURE, SnowflakeParserGCP_PUBSUB, SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, SnowflakeParserGCP_PUBSUB_TOPIC_NAME, SnowflakeParserGCS, SnowflakeParserGENERIC_Q, SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, SnowflakeParserGEO, SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, SnowflakeParserGEOMETRY_OUTPUT_FORMAT, SnowflakeParserGET, SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, SnowflakeParserGLOBAL, SnowflakeParserGOOGLE_AUDIENCE, SnowflakeParserGOTO, SnowflakeParserGRANTS, SnowflakeParserGROUPING, SnowflakeParserGROUPING_ID, SnowflakeParserGROUPS, SnowflakeParserGZIP, SnowflakeParserHEADER, SnowflakeParserHEADERS, SnowflakeParserHEX, SnowflakeParserHIERARCHYID, SnowflakeParserHIGH, SnowflakeParserHISTORY, SnowflakeParserHOURS, SnowflakeParserIDENTITY, SnowflakeParserIF, SnowflakeParserIFF, SnowflakeParserIFNULL, SnowflakeParserIGNORE, SnowflakeParserIGNORE_CONSTRAINTS, SnowflakeParserIGNORE_DUP_KEY, SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, SnowflakeParserIGNORE_TRIGGERS, SnowflakeParserIMMEDIATE, SnowflakeParserIMMEDIATELY, SnowflakeParserIMMUTABLE, SnowflakeParserIMPLICIT, SnowflakeParserIMPORT, SnowflakeParserIMPORTED, SnowflakeParserINDEX, SnowflakeParserINFORMATION, SnowflakeParserINIT, SnowflakeParserINITIALLY, SnowflakeParserINITIALLY_SUSPENDED, SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, SnowflakeParserINPUT, SnowflakeParserINSERT_ONLY, SnowflakeParserINSTEAD, SnowflakeParserINT, SnowflakeParserINTEGRATION, SnowflakeParserINTEGRATIONS, SnowflakeParserISNULL, SnowflakeParserISNUMERIC, SnowflakeParserISOLATION, SnowflakeParserJAVASCRIPT, SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, SnowflakeParserJDBC_USE_SESSION_TIMEZONE, SnowflakeParserJSON, SnowflakeParserJSON_Q, SnowflakeParserJSON_INDENT, SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, SnowflakeParserKB, SnowflakeParserKEEP, SnowflakeParserKEY, SnowflakeParserKEYS, SnowflakeParserKEYSET, SnowflakeParserKMS_KEY_ID, SnowflakeParserLAG, SnowflakeParserLANGUAGE, SnowflakeParserLARGE, SnowflakeParserLAST, SnowflakeParserLAST_NAME, SnowflakeParserLAST_QUERY_ID, SnowflakeParserLAST_VALUE, SnowflakeParserLEAD, SnowflakeParserLEN, SnowflakeParserLENGTH, SnowflakeParserLEVEL, SnowflakeParserLIMIT, SnowflakeParserLINENO, SnowflakeParserLIST, SnowflakeParserLISTENER_IP, SnowflakeParserLISTENER_PORT, SnowflakeParserLISTING, SnowflakeParserLOAD, SnowflakeParserLOCAL, SnowflakeParserLOCAL_SERVICE_NAME, SnowflakeParserLOCATION, SnowflakeParserLOCKS, SnowflakeParserLOCK_TIMEOUT, SnowflakeParserLOG, SnowflakeParserLOGIN, SnowflakeParserLOGIN_NAME, SnowflakeParserLOOKER, SnowflakeParserLOW, SnowflakeParserLOWER, SnowflakeParserLTRIM, SnowflakeParserLZO, SnowflakeParserMANAGE, SnowflakeParserMANAGED, SnowflakeParserMASK, SnowflakeParserMASKED, SnowflakeParserMASKING, SnowflakeParserMASTER, SnowflakeParserMASTER_KEY, SnowflakeParserMATCH, SnowflakeParserMATCHED, SnowflakeParserMATCHES, SnowflakeParserMATCH_BY_COLUMN_NAME, SnowflakeParserMATCH_RECOGNIZE, SnowflakeParserMATERIALIZED, SnowflakeParserMAX_BATCH_ROWS, SnowflakeParserMAX_CLUSTER_COUNT, SnowflakeParserMAX_CONCURRENCY_LEVEL, SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, SnowflakeParserMAX_SIZE, SnowflakeParserMEASURES, SnowflakeParserMEDIUM, SnowflakeParserMEMOIZABLE, SnowflakeParserMERGE, SnowflakeParserMIDDLE_NAME, SnowflakeParserMIN, SnowflakeParserMINS_TO_BYPASS_MFA, SnowflakeParserMINS_TO_UNLOCK, SnowflakeParserMINUS_, SnowflakeParserMINUTES, SnowflakeParserMIN_CLUSTER_COUNT, SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, SnowflakeParserMODE, SnowflakeParserMODIFIED_AFTER, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserMONITORS, SnowflakeParserMONTHLY, SnowflakeParserMOVE, SnowflakeParserMULTI_STATEMENT_COUNT, SnowflakeParserMULTI_USER, SnowflakeParserMUST_CHANGE, SnowflakeParserMUST_CHANGE_PASSWORD, SnowflakeParserNAME, SnowflakeParserNCHAR, SnowflakeParserNESTED_TRIGGERS, SnowflakeParserNETWORK, SnowflakeParserNETWORK_POLICY, SnowflakeParserNEVER, SnowflakeParserNEWID, SnowflakeParserNEWNAME, SnowflakeParserNEWSEQUENTIALID, SnowflakeParserNEW_ACCOUNT, SnowflakeParserNEW_BROKER, SnowflakeParserNEW_PASSWORD, SnowflakeParserNEXT, SnowflakeParserNEXTVAL, SnowflakeParserNO, SnowflakeParserNONE, SnowflakeParserNONE_Q, SnowflakeParserNORELY, SnowflakeParserNOTIFICATION, SnowflakeParserNOTIFICATIONS, SnowflakeParserNOTIFICATION_INTEGRATION, SnowflakeParserNOTIFICATION_PROVIDER, SnowflakeParserNOTIFY, SnowflakeParserNOTIFY_USERS, SnowflakeParserNOVALIDATE, SnowflakeParserNTILE, SnowflakeParserNULLIF, SnowflakeParserNULLS, SnowflakeParserNULL_, SnowflakeParserNULL_IF, SnowflakeParserNUMANODE, SnowflakeParserNUMBER, SnowflakeParserNUMERIC_ROUNDABORT, SnowflakeParserNVL, SnowflakeParserOAUTH, SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, SnowflakeParserOAUTH_CLIENT, SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, SnowflakeParserOAUTH_ENFORCE_PKCE, SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, SnowflakeParserOAUTH_REDIRECT_URI, SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, SnowflakeParserOAUTH_USE_SECONDARY_ROLES, SnowflakeParserOBJECT, SnowflakeParserOBJECT_Q, SnowflakeParserOBJECTS, SnowflakeParserOBJECT_TYPES, SnowflakeParserOFF, SnowflakeParserOFFSET, SnowflakeParserOFFSETS, SnowflakeParserOKTA, SnowflakeParserOKTA_PROVISIONER_Q, SnowflakeParserOKTA_Q, SnowflakeParserOLD, SnowflakeParserOLD_ACCOUNT, SnowflakeParserOLD_PASSWORD, SnowflakeParserOMIT, SnowflakeParserONE, SnowflakeParserONLINE, SnowflakeParserONLY, SnowflakeParserON_ERROR, SnowflakeParserON_FAILURE, SnowflakeParserOPEN, SnowflakeParserOPERATE, SnowflakeParserOPERATIONS, SnowflakeParserOPTIMIZATION, SnowflakeParserOPTION, SnowflakeParserORC, SnowflakeParserORC_Q, SnowflakeParserORGADMIN, SnowflakeParserOUTBOUND, SnowflakeParserOUTER, SnowflakeParserOVER, SnowflakeParserOVERRIDE, SnowflakeParserOVERWRITE, SnowflakeParserOWNER, SnowflakeParserOWNERSHIP, SnowflakeParserPAGE, SnowflakeParserPARALLEL, SnowflakeParserPARAMETERS, SnowflakeParserPARAM_NODE, SnowflakeParserPARQUET, SnowflakeParserPARQUET_Q, SnowflakeParserPARTIAL, SnowflakeParserPARTITION, SnowflakeParserPARTITIONS, SnowflakeParserPARTITION_TYPE, SnowflakeParserPASSWORD, SnowflakeParserPAST, SnowflakeParserPATH_, SnowflakeParserPATTERN, SnowflakeParserPER, SnowflakeParserPERCENT, SnowflakeParserPERCENTILE_CONT, SnowflakeParserPERCENTILE_DISC, SnowflakeParserPERCENT_RANK, SnowflakeParserPERIODIC_DATA_REKEYING, SnowflakeParserPERMISSION_SET, SnowflakeParserPERSISTED, SnowflakeParserPERSIST_SAMPLE_PERCENT, SnowflakeParserPING_FEDERATE, SnowflakeParserPIPE, SnowflakeParserPIPES, SnowflakeParserPIPE_EXECUTION_PAUSED, SnowflakeParserPIVOT, SnowflakeParserPLAN, SnowflakeParserPLATFORM, SnowflakeParserPOLICIES, SnowflakeParserPOLICY, SnowflakeParserPOOL, SnowflakeParserPORT, SnowflakeParserPRECEDING, SnowflakeParserPRECISION, SnowflakeParserPREDICATE, SnowflakeParserPREFIX, SnowflakeParserPRESERVE_SPACE, SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, SnowflakeParserPRIMARY, SnowflakeParserPRIMARY_ROLE, SnowflakeParserPRIOR, SnowflakeParserPRIORITY, SnowflakeParserPRIORITY_LEVEL, SnowflakeParserPRIVATE, SnowflakeParserPRIVATE_KEY, SnowflakeParserPRIVILEGES, SnowflakeParserPROC, SnowflakeParserPROCEDURE, SnowflakeParserPROCEDURES, SnowflakeParserPROCEDURE_NAME, SnowflakeParserPROCESS, SnowflakeParserPROFILE, SnowflakeParserPROPERTY, SnowflakeParserPROVIDER, SnowflakeParserPROVIDER_KEY_NAME, SnowflakeParserPUBLIC, SnowflakeParserPURGE, SnowflakeParserPUT, SnowflakeParserPYTHON, SnowflakeParserQUERIES, SnowflakeParserQUERY, SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, SnowflakeParserQUERY_TAG, SnowflakeParserQUEUE, SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, SnowflakeParserRANGE, SnowflakeParserRANK, SnowflakeParserRAW_DEFLATE, SnowflakeParserREAD, SnowflakeParserREADER, SnowflakeParserREADONLY, SnowflakeParserREADPAST, SnowflakeParserREADTEXT, SnowflakeParserREADWRITE, SnowflakeParserREAD_COMMITTED_SNAPSHOT, SnowflakeParserREAD_ONLY, SnowflakeParserREAD_ONLY_ROUTING_LIST, SnowflakeParserREAD_WRITE, SnowflakeParserREBUILD, SnowflakeParserRECEIVE, SnowflakeParserRECLUSTER, SnowflakeParserRECOMPILE, SnowflakeParserRECONFIGURE, SnowflakeParserRECORD_DELIMITER, SnowflakeParserRECOVERY, SnowflakeParserRECURSIVE, SnowflakeParserRECURSIVE_TRIGGERS, SnowflakeParserREFERENCES, SnowflakeParserREFERENCE_USAGE, SnowflakeParserREFRESH, SnowflakeParserREFRESH_ON_CREATE, SnowflakeParserREGION, SnowflakeParserREGIONS, SnowflakeParserREGION_GROUP, SnowflakeParserRELATIVE, SnowflakeParserRELY, SnowflakeParserREMOTE, SnowflakeParserREMOTE_PROC_TRANSACTIONS, SnowflakeParserREMOTE_SERVICE_NAME, SnowflakeParserREMOVE, SnowflakeParserRENAME, SnowflakeParserREPEATABLE, SnowflakeParserREPLACE, SnowflakeParserREPLACE_INVALID_CHARACTERS, SnowflakeParserREPLICA, SnowflakeParserREPLICATION, SnowflakeParserREPLICATION_SCHEDULE, SnowflakeParserREQUEST_TRANSLATOR, SnowflakeParserREQUIRED, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, SnowflakeParserRESET, SnowflakeParserRESOURCE, SnowflakeParserRESOURCES, SnowflakeParserRESOURCE_MONITOR, SnowflakeParserRESPONSE_TRANSLATOR, SnowflakeParserRESTART, SnowflakeParserRESTORE, SnowflakeParserRESTRICT, SnowflakeParserRESTRICTIONS, SnowflakeParserRESULT, SnowflakeParserRESUME, SnowflakeParserRETAINDAYS, SnowflakeParserRETURN, SnowflakeParserRETURNS, SnowflakeParserRETURN_ALL_ERRORS, SnowflakeParserRETURN_ERRORS, SnowflakeParserRETURN_FAILED_ONLY, SnowflakeParserRETURN_N_ROWS, SnowflakeParserRETURN_ROWS, SnowflakeParserREVERSE, SnowflakeParserREVERT, SnowflakeParserREWIND, SnowflakeParserROLE, SnowflakeParserROLES, SnowflakeParserROLLBACK, SnowflakeParserROLLUP, SnowflakeParserROOT, SnowflakeParserROWCOUNT, SnowflakeParserROWGUID, SnowflakeParserROWLOCK, SnowflakeParserROWS_PER_RESULTSET, SnowflakeParserROW_NUMBER, SnowflakeParserRSA_PUBLIC_KEY, SnowflakeParserRTRIM, SnowflakeParserRUN_AS_ROLE, SnowflakeParserSAFE, SnowflakeParserSAFETY, SnowflakeParserSAML_IDENTITY_PROVIDER, SnowflakeParserSAVE_OLD_URL, SnowflakeParserSCALING_POLICY, SnowflakeParserSCHEDULE, SnowflakeParserSCHEDULER, SnowflakeParserSCHEMAS, SnowflakeParserSCHEME, SnowflakeParserSCIM, SnowflakeParserSCIM_CLIENT, SnowflakeParserSCRIPT, SnowflakeParserSEARCH, SnowflakeParserSECONDARY, SnowflakeParserSECONDARY_ONLY, SnowflakeParserSECONDARY_ROLE, SnowflakeParserSECONDS, SnowflakeParserSECRET, SnowflakeParserSECURE, SnowflakeParserSECURITY, SnowflakeParserSECURITYADMIN, SnowflakeParserSEED, SnowflakeParserSELF, SnowflakeParserSEQUENCE, SnowflakeParserSEQUENCES, SnowflakeParserSERVER, SnowflakeParserSERVICE, SnowflakeParserSESSION, SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, SnowflakeParserSESSION_POLICY, SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, SnowflakeParserSETS, SnowflakeParserSETUSER, SnowflakeParserSHARE, SnowflakeParserSHARED, SnowflakeParserSHARES, SnowflakeParserSHARE_RESTRICTIONS, SnowflakeParserSHOW, SnowflakeParserSHOWPLAN, SnowflakeParserSHOWPLAN_ALL, SnowflakeParserSHOWPLAN_TEXT, SnowflakeParserSHOWPLAN_XML, SnowflakeParserSHOW_INITIAL_ROWS, SnowflakeParserSIGNATURE, SnowflakeParserSIMPLE, SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, SnowflakeParserSINGLE_USER, SnowflakeParserSIZE, SnowflakeParserSIZE_LIMIT, SnowflakeParserSKIP_, SnowflakeParserSKIP_BLANK_LINES, SnowflakeParserSKIP_BYTE_ORDER_MARK, SnowflakeParserSKIP_FILE, SnowflakeParserSKIP_FILE_N, SnowflakeParserSKIP_HEADER, SnowflakeParserSMALL, SnowflakeParserSNAPPY, SnowflakeParserSNAPPY_COMPRESSION, SnowflakeParserSOUNDEX, SnowflakeParserSOURCE, SnowflakeParserSOURCE_COMPRESSION, SnowflakeParserSPACE_KEYWORD, SnowflakeParserSPARSE, SnowflakeParserSPECIFICATION, SnowflakeParserSPLIT, SnowflakeParserSPLIT_PART, SnowflakeParserSQL, SnowflakeParserSSO_LOGIN_PAGE, SnowflakeParserSTAGE, SnowflakeParserSTAGES, SnowflakeParserSTAGE_COPY_OPTIONS, SnowflakeParserSTAGE_FILE_FORMAT, SnowflakeParserSTANDARD, SnowflakeParserSTANDBY, SnowflakeParserSTARTED, SnowflakeParserSTARTS, SnowflakeParserSTART_DATE, SnowflakeParserSTART_TIMESTAMP, SnowflakeParserSTATE, SnowflakeParserSTATEMENT, SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, SnowflakeParserSTATIC, SnowflakeParserSTATISTICS, SnowflakeParserSTATS, SnowflakeParserSTATS_DATE, SnowflakeParserSTATS_STREAM, SnowflakeParserSTATUS, SnowflakeParserSTATUSONLY, SnowflakeParserSTDEV, SnowflakeParserSTDEVP, SnowflakeParserSTOP, SnowflakeParserSTOPLIST, SnowflakeParserSTOPPED, SnowflakeParserSTORAGE, SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, SnowflakeParserSTORAGE_AWS_OBJECT_ACL, SnowflakeParserSTORAGE_AWS_ROLE_ARN, SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, SnowflakeParserSTORAGE_INTEGRATION, SnowflakeParserSTORAGE_PROVIDER, SnowflakeParserSTR, SnowflakeParserSTREAM, SnowflakeParserSTREAMS, SnowflakeParserSTRICT, SnowflakeParserSTRICT_JSON_OUTPUT, SnowflakeParserSTRING_AGG, SnowflakeParserSTRING_ESCAPE, SnowflakeParserSTRIP_NULL_VALUES, SnowflakeParserSTRIP_OUTER_ARRAY, SnowflakeParserSTRIP_OUTER_ELEMENT, SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING, SnowflakeParserSUM, SnowflakeParserSUPPORTED, SnowflakeParserSUSPEND, SnowflakeParserSUSPENDED, SnowflakeParserSUSPEND_IMMEDIATE, SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, SnowflakeParserSWAP, SnowflakeParserSWITCH, SnowflakeParserSYNC_PASSWORD, SnowflakeParserSYSADMIN, SnowflakeParserSYSTEM, SnowflakeParserSYSTEM_USER, SnowflakeParserTABLEAU_DESKTOP, SnowflakeParserTABLEAU_SERVER, SnowflakeParserTABLES, SnowflakeParserTABLE_FORMAT, SnowflakeParserTABULAR, SnowflakeParserTAG, SnowflakeParserTAGS, SnowflakeParserTARGET, SnowflakeParserTARGET_LAG, SnowflakeParserTASK, SnowflakeParserTASKS, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserTERSE, SnowflakeParserTEXTSIZE, SnowflakeParserTIES, SnowflakeParserTIME, SnowflakeParserTIMEADD, SnowflakeParserTIMEDIFF, SnowflakeParserTIMEOUT, SnowflakeParserTIMER, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_FORMAT, SnowflakeParserTIMESTAMP_INPUT_FORMAT, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_TYPE_MAPPING, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMPADD, SnowflakeParserTIMESTAMPDIFF, SnowflakeParserTIMEZONE, SnowflakeParserTIME_FORMAT, SnowflakeParserTIME_INPUT_FORMAT, SnowflakeParserTIME_OUTPUT_FORMAT, SnowflakeParserTO_BOOLEAN, SnowflakeParserTO_DATE, SnowflakeParserTOP, SnowflakeParserTORN_PAGE_DETECTION, SnowflakeParserTRACKING, SnowflakeParserTRACK_CAUSALITY, SnowflakeParserTRAN, SnowflakeParserTRANSACTION, SnowflakeParserTRANSACTIONS, SnowflakeParserTRANSACTION_ABORT_ON_ERROR, SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, SnowflakeParserTRANSACTION_ID, SnowflakeParserTRANSFORM_NOISE_WORDS, SnowflakeParserTRANSIENT, SnowflakeParserTRANSLATE, SnowflakeParserTRIGGERS, SnowflakeParserTRIM, SnowflakeParserTRIM_SPACE, SnowflakeParserTRIPLE_DES, SnowflakeParserTRUNCATE, SnowflakeParserTRUNCATECOLUMNS, SnowflakeParserTRUSTWORTHY, SnowflakeParserTRY, SnowflakeParserTSEQUAL, SnowflakeParserTSQL, SnowflakeParserTWO_DIGIT_CENTURY_START, SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, SnowflakeParserTYPE, SnowflakeParserTYPEPROPERTY, SnowflakeParserTYPE_ID, SnowflakeParserTYPE_NAME, SnowflakeParserTYPE_WARNING, SnowflakeParserUN, SnowflakeParserUNBOUNDED, SnowflakeParserUNCHECKED, SnowflakeParserUNCOMMITTED, SnowflakeParserUNDROP, SnowflakeParserUNICODE, SnowflakeParserUNKNOWN, SnowflakeParserUNLIMITED, SnowflakeParserUNLOCK, SnowflakeParserUNMASK, SnowflakeParserUNMATCHED, SnowflakeParserUNPIVOT, SnowflakeParserUNSAFE, SnowflakeParserUNSET, SnowflakeParserUNSUPPORTED_DDL_ACTION, SnowflakeParserUOW, SnowflakeParserUPDLOCK, SnowflakeParserUPPER, SnowflakeParserURL, SnowflakeParserUSAGE, SnowflakeParserUSE, SnowflakeParserUSED, SnowflakeParserUSER, SnowflakeParserUSERADMIN, SnowflakeParserUSERS, SnowflakeParserUSER_SPECIFIED, SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, SnowflakeParserUSER_TASK_TIMEOUT_MS, SnowflakeParserUSE_ANY_ROLE, SnowflakeParserUSE_CACHED_RESULT, SnowflakeParserVALIDATE, SnowflakeParserVALIDATION, SnowflakeParserVALIDATION_MODE, SnowflakeParserVALID_XML, SnowflakeParserVALUE, SnowflakeParserVAR, SnowflakeParserVARIABLES, SnowflakeParserVARP, SnowflakeParserVARYING, SnowflakeParserVERSION, SnowflakeParserVIEWS, SnowflakeParserVIEW_METADATA, SnowflakeParserVISIBILITY, SnowflakeParserVOLATILE, SnowflakeParserWAIT, SnowflakeParserWAREHOUSE, SnowflakeParserWAREHOUSES, SnowflakeParserWAREHOUSE_SIZE, SnowflakeParserWEEKLY, SnowflakeParserWEEK_OF_YEAR_POLICY, SnowflakeParserWEEK_START, SnowflakeParserWELL_FORMED_XML, SnowflakeParserWITHIN, SnowflakeParserWITHOUT, SnowflakeParserWITHOUT_ARRAY_WRAPPER, SnowflakeParserWORK, SnowflakeParserWORKLOAD, SnowflakeParserWRITE, SnowflakeParserXLARGE, SnowflakeParserXLOCK, SnowflakeParserXML, SnowflakeParserXML_Q, SnowflakeParserXSMALL, SnowflakeParserXXLARGE, SnowflakeParserXXXLARGE, SnowflakeParserYEARLY, SnowflakeParserZSTD, SnowflakeParserARRAY, SnowflakeParserARRAY_Q, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserCHAR_VARYING, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNCHAR_VARYING, SnowflakeParserNUMERIC, SnowflakeParserNVARCHAR, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT, SnowflakeParserLISTAGG, SnowflakeParserDUMMY, SnowflakeParserDOUBLE_QUOTE_ID, SnowflakeParserDOUBLE_QUOTE_BLANK, SnowflakeParserID, SnowflakeParserID2: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1282) + p.Object_name() + } + + case SnowflakeParserLR_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1283) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1284) + p.Subquery() + } + { + p.SetState(1285) + p.Match(SnowflakeParserRR_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 +} + +// IDelete_statementContext is an interface to support dynamic dispatch. +type IDelete_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE() antlr.TerminalNode + FROM() antlr.TerminalNode + Object_name() IObject_nameContext + USING() antlr.TerminalNode + AllTable_or_query() []ITable_or_queryContext + Table_or_query(i int) ITable_or_queryContext + WHERE() antlr.TerminalNode + Search_condition() ISearch_conditionContext + COMMA() antlr.TerminalNode + + // IsDelete_statementContext differentiates from other interfaces. + IsDelete_statementContext() +} + +type Delete_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelete_statementContext() *Delete_statementContext { + var p = new(Delete_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_delete_statement + return p +} + +func InitEmptyDelete_statementContext(p *Delete_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_delete_statement +} + +func (*Delete_statementContext) IsDelete_statementContext() {} + +func NewDelete_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_statementContext { + var p = new(Delete_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_delete_statement + + return p +} + +func (s *Delete_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_statementContext) DELETE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELETE, 0) +} + +func (s *Delete_statementContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Delete_statementContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Delete_statementContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *Delete_statementContext) AllTable_or_query() []ITable_or_queryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_or_queryContext); ok { + len++ + } + } + + tst := make([]ITable_or_queryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_or_queryContext); ok { + tst[i] = t.(ITable_or_queryContext) + i++ + } + } + + return tst +} + +func (s *Delete_statementContext) Table_or_query(i int) ITable_or_queryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_or_queryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_or_queryContext) +} + +func (s *Delete_statementContext) WHERE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHERE, 0) +} + +func (s *Delete_statementContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Delete_statementContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Delete_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDelete_statement(s) + } +} + +func (s *Delete_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDelete_statement(s) + } +} + +func (s *Delete_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDelete_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Delete_statement() (localctx IDelete_statementContext) { + localctx = NewDelete_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, SnowflakeParserRULE_delete_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1289) + p.Match(SnowflakeParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1290) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1291) + p.Object_name() + } + p.SetState(1298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(1292) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1293) + p.Table_or_query() + } + p.SetState(1296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMA { + { + p.SetState(1294) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1295) + p.Table_or_query() + } + + } + + } + p.SetState(1302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWHERE { + { + p.SetState(1300) + p.Match(SnowflakeParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1301) + p.search_condition(0) + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_builderContext is an interface to support dynamic dispatch. +type IValues_builderContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllExpr_list() []IExpr_listContext + Expr_list(i int) IExpr_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsValues_builderContext differentiates from other interfaces. + IsValues_builderContext() +} + +type Values_builderContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValues_builderContext() *Values_builderContext { + var p = new(Values_builderContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_values_builder + return p +} + +func InitEmptyValues_builderContext(p *Values_builderContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_values_builder +} + +func (*Values_builderContext) IsValues_builderContext() {} + +func NewValues_builderContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Values_builderContext { + var p = new(Values_builderContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_values_builder + + return p +} + +func (s *Values_builderContext) GetParser() antlr.Parser { return s.parser } + +func (s *Values_builderContext) VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALUES, 0) +} + +func (s *Values_builderContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Values_builderContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Values_builderContext) 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_builderContext) 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_builderContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Values_builderContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Values_builderContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Values_builderContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Values_builderContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Values_builderContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterValues_builder(s) + } +} + +func (s *Values_builderContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitValues_builder(s) + } +} + +func (s *Values_builderContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitValues_builder(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Values_builder() (localctx IValues_builderContext) { + localctx = NewValues_builderContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, SnowflakeParserRULE_values_builder) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1304) + p.Match(SnowflakeParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1305) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1306) + p.Expr_list() + } + { + p.SetState(1307) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1313) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMA { + { + p.SetState(1308) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1309) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1310) + p.Expr_list() + } + { + p.SetState(1311) + p.Match(SnowflakeParserRR_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 +} + +// IOther_commandContext is an interface to support dynamic dispatch. +type IOther_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Copy_into_table() ICopy_into_tableContext + Copy_into_location() ICopy_into_locationContext + Comment() ICommentContext + Commit() ICommitContext + Execute_immediate() IExecute_immediateContext + Execute_task() IExecute_taskContext + Explain() IExplainContext + Get_dml() IGet_dmlContext + Grant_ownership() IGrant_ownershipContext + Grant_to_role() IGrant_to_roleContext + Grant_to_share() IGrant_to_shareContext + Grant_role() IGrant_roleContext + List() IListContext + Put() IPutContext + Remove() IRemoveContext + Revoke_from_role() IRevoke_from_roleContext + Revoke_from_share() IRevoke_from_shareContext + Revoke_role() IRevoke_roleContext + Rollback() IRollbackContext + Set() ISetContext + Truncate_materialized_view() ITruncate_materialized_viewContext + Truncate_table() ITruncate_tableContext + Unset() IUnsetContext + Call() ICallContext + + // IsOther_commandContext differentiates from other interfaces. + IsOther_commandContext() +} + +type Other_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOther_commandContext() *Other_commandContext { + var p = new(Other_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_other_command + return p +} + +func InitEmptyOther_commandContext(p *Other_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_other_command +} + +func (*Other_commandContext) IsOther_commandContext() {} + +func NewOther_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Other_commandContext { + var p = new(Other_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_other_command + + return p +} + +func (s *Other_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Other_commandContext) Copy_into_table() ICopy_into_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_into_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_into_tableContext) +} + +func (s *Other_commandContext) Copy_into_location() ICopy_into_locationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_into_locationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_into_locationContext) +} + +func (s *Other_commandContext) Comment() ICommentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommentContext) +} + +func (s *Other_commandContext) Commit() ICommitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommitContext) +} + +func (s *Other_commandContext) Execute_immediate() IExecute_immediateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_immediateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_immediateContext) +} + +func (s *Other_commandContext) Execute_task() IExecute_taskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecute_taskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecute_taskContext) +} + +func (s *Other_commandContext) Explain() IExplainContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplainContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplainContext) +} + +func (s *Other_commandContext) Get_dml() IGet_dmlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGet_dmlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGet_dmlContext) +} + +func (s *Other_commandContext) Grant_ownership() IGrant_ownershipContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_ownershipContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_ownershipContext) +} + +func (s *Other_commandContext) Grant_to_role() IGrant_to_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_to_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_to_roleContext) +} + +func (s *Other_commandContext) Grant_to_share() IGrant_to_shareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_to_shareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_to_shareContext) +} + +func (s *Other_commandContext) Grant_role() IGrant_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_roleContext) +} + +func (s *Other_commandContext) List() IListContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IListContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IListContext) +} + +func (s *Other_commandContext) Put() IPutContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPutContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPutContext) +} + +func (s *Other_commandContext) Remove() IRemoveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRemoveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRemoveContext) +} + +func (s *Other_commandContext) Revoke_from_role() IRevoke_from_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_from_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_from_roleContext) +} + +func (s *Other_commandContext) Revoke_from_share() IRevoke_from_shareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_from_shareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_from_shareContext) +} + +func (s *Other_commandContext) Revoke_role() IRevoke_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_roleContext) +} + +func (s *Other_commandContext) Rollback() IRollbackContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollbackContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollbackContext) +} + +func (s *Other_commandContext) Set() ISetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISetContext) +} + +func (s *Other_commandContext) Truncate_materialized_view() ITruncate_materialized_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_materialized_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_materialized_viewContext) +} + +func (s *Other_commandContext) Truncate_table() ITruncate_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_tableContext) +} + +func (s *Other_commandContext) Unset() IUnsetContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnsetContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnsetContext) +} + +func (s *Other_commandContext) Call() ICallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICallContext) +} + +func (s *Other_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Other_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Other_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterOther_command(s) + } +} + +func (s *Other_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitOther_command(s) + } +} + +func (s *Other_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitOther_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Other_command() (localctx IOther_commandContext) { + localctx = NewOther_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, SnowflakeParserRULE_other_command) + p.SetState(1339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 34, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1315) + p.Copy_into_table() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1316) + p.Copy_into_location() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1317) + p.Comment() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1318) + p.Commit() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1319) + p.Execute_immediate() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1320) + p.Execute_task() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1321) + p.Explain() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1322) + p.Get_dml() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1323) + p.Grant_ownership() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1324) + p.Grant_to_role() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1325) + p.Grant_to_share() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(1326) + p.Grant_role() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(1327) + p.List() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(1328) + p.Put() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(1329) + p.Remove() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(1330) + p.Revoke_from_role() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(1331) + p.Revoke_from_share() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(1332) + p.Revoke_role() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(1333) + p.Rollback() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(1334) + p.Set() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(1335) + p.Truncate_materialized_view() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(1336) + p.Truncate_table() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(1337) + p.Unset() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(1338) + p.Call() + } + + 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_into_tableContext is an interface to support dynamic dispatch. +type ICopy_into_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COPY() antlr.TerminalNode + INTO() antlr.TerminalNode + Object_name() IObject_nameContext + FROM() antlr.TerminalNode + Internal_stage() IInternal_stageContext + External_stage() IExternal_stageContext + External_location() IExternal_locationContext + Files() IFilesContext + Pattern() IPatternContext + File_format() IFile_formatContext + AllCopy_options() []ICopy_optionsContext + Copy_options(i int) ICopy_optionsContext + VALIDATION_MODE() antlr.TerminalNode + EQ() antlr.TerminalNode + RETURN_N_ROWS() antlr.TerminalNode + RETURN_ERRORS() antlr.TerminalNode + RETURN_ALL_ERRORS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_list() IColumn_listContext + RR_BRACKET() antlr.TerminalNode + + // IsCopy_into_tableContext differentiates from other interfaces. + IsCopy_into_tableContext() +} + +type Copy_into_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_into_tableContext() *Copy_into_tableContext { + var p = new(Copy_into_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_copy_into_table + return p +} + +func InitEmptyCopy_into_tableContext(p *Copy_into_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_copy_into_table +} + +func (*Copy_into_tableContext) IsCopy_into_tableContext() {} + +func NewCopy_into_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_into_tableContext { + var p = new(Copy_into_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_copy_into_table + + return p +} + +func (s *Copy_into_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_into_tableContext) COPY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY, 0) +} + +func (s *Copy_into_tableContext) INTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTO, 0) +} + +func (s *Copy_into_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Copy_into_tableContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Copy_into_tableContext) Internal_stage() IInternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInternal_stageContext) +} + +func (s *Copy_into_tableContext) External_stage() IExternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_stageContext) +} + +func (s *Copy_into_tableContext) External_location() IExternal_locationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_locationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_locationContext) +} + +func (s *Copy_into_tableContext) Files() IFilesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilesContext) +} + +func (s *Copy_into_tableContext) Pattern() IPatternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPatternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPatternContext) +} + +func (s *Copy_into_tableContext) File_format() IFile_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_formatContext) +} + +func (s *Copy_into_tableContext) AllCopy_options() []ICopy_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICopy_optionsContext); ok { + len++ + } + } + + tst := make([]ICopy_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICopy_optionsContext); ok { + tst[i] = t.(ICopy_optionsContext) + i++ + } + } + + return tst +} + +func (s *Copy_into_tableContext) Copy_options(i int) ICopy_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICopy_optionsContext) +} + +func (s *Copy_into_tableContext) VALIDATION_MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALIDATION_MODE, 0) +} + +func (s *Copy_into_tableContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Copy_into_tableContext) RETURN_N_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_N_ROWS, 0) +} + +func (s *Copy_into_tableContext) RETURN_ERRORS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_ERRORS, 0) +} + +func (s *Copy_into_tableContext) RETURN_ALL_ERRORS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_ALL_ERRORS, 0) +} + +func (s *Copy_into_tableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Copy_into_tableContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Copy_into_tableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Copy_into_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_into_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_into_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCopy_into_table(s) + } +} + +func (s *Copy_into_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCopy_into_table(s) + } +} + +func (s *Copy_into_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCopy_into_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Copy_into_table() (localctx ICopy_into_tableContext) { + localctx = NewCopy_into_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, SnowflakeParserRULE_copy_into_table) + var _la int + + p.SetState(1394) + 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(1341) + p.Match(SnowflakeParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1342) + p.Match(SnowflakeParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1343) + p.Object_name() + } + { + p.SetState(1344) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 35, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1345) + p.Internal_stage() + } + + case 2: + { + p.SetState(1346) + p.External_stage() + } + + case 3: + { + p.SetState(1347) + p.External_location() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(1351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILES { + { + p.SetState(1350) + p.Files() + } + + } + p.SetState(1354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPATTERN { + { + p.SetState(1353) + p.Pattern() + } + + } + p.SetState(1357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILE_FORMAT { + { + p.SetState(1356) + p.File_format() + } + + } + p.SetState(1362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCASE_INSENSITIVE || _la == SnowflakeParserENFORCE_LENGTH || _la == SnowflakeParserFORCE || _la == SnowflakeParserMATCH_BY_COLUMN_NAME || _la == SnowflakeParserNONE || _la == SnowflakeParserON_ERROR || _la == SnowflakeParserPURGE || _la == SnowflakeParserRETURN_FAILED_ONLY || _la == SnowflakeParserSIZE_LIMIT || _la == SnowflakeParserTRUNCATECOLUMNS { + { + p.SetState(1359) + p.Copy_options() + } + + p.SetState(1364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(1368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserVALIDATION_MODE { + { + p.SetState(1365) + p.Match(SnowflakeParserVALIDATION_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1366) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1367) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-707)) & ^0x3f) == 0 && ((int64(1)<<(_la-707))&11) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1370) + p.Match(SnowflakeParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1371) + p.Match(SnowflakeParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1372) + p.Object_name() + } + p.SetState(1377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(1373) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1374) + p.Column_list() + } + { + p.SetState(1375) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILES { + { + p.SetState(1379) + p.Files() + } + + } + p.SetState(1383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPATTERN { + { + p.SetState(1382) + p.Pattern() + } + + } + p.SetState(1386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILE_FORMAT { + { + p.SetState(1385) + p.File_format() + } + + } + p.SetState(1391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCASE_INSENSITIVE || _la == SnowflakeParserENFORCE_LENGTH || _la == SnowflakeParserFORCE || _la == SnowflakeParserMATCH_BY_COLUMN_NAME || _la == SnowflakeParserNONE || _la == SnowflakeParserON_ERROR || _la == SnowflakeParserPURGE || _la == SnowflakeParserRETURN_FAILED_ONLY || _la == SnowflakeParserSIZE_LIMIT || _la == SnowflakeParserTRUNCATECOLUMNS { + { + p.SetState(1388) + p.Copy_options() + } + + p.SetState(1393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + 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 +} + +// IExternal_locationContext is an interface to support dynamic dispatch. +type IExternal_locationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + S3_PATH() antlr.TerminalNode + GCS_PATH() antlr.TerminalNode + AZURE_PATH() antlr.TerminalNode + + // IsExternal_locationContext differentiates from other interfaces. + IsExternal_locationContext() +} + +type External_locationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_locationContext() *External_locationContext { + var p = new(External_locationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_location + return p +} + +func InitEmptyExternal_locationContext(p *External_locationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_location +} + +func (*External_locationContext) IsExternal_locationContext() {} + +func NewExternal_locationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_locationContext { + var p = new(External_locationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_external_location + + return p +} + +func (s *External_locationContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_locationContext) S3_PATH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserS3_PATH, 0) +} + +func (s *External_locationContext) GCS_PATH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCS_PATH, 0) +} + +func (s *External_locationContext) AZURE_PATH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_PATH, 0) +} + +func (s *External_locationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_locationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_locationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExternal_location(s) + } +} + +func (s *External_locationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExternal_location(s) + } +} + +func (s *External_locationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExternal_location(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) External_location() (localctx IExternal_locationContext) { + localctx = NewExternal_locationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, SnowflakeParserRULE_external_location) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1396) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1078)) & ^0x3f) == 0 && ((int64(1)<<(_la-1078))&7) != 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 +} + +// IFilesContext is an interface to support dynamic dispatch. +type IFilesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILES() antlr.TerminalNode + EQ() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFilesContext differentiates from other interfaces. + IsFilesContext() +} + +type FilesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilesContext() *FilesContext { + var p = new(FilesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_files + return p +} + +func InitEmptyFilesContext(p *FilesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_files +} + +func (*FilesContext) IsFilesContext() {} + +func NewFilesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilesContext { + var p = new(FilesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_files + + return p +} + +func (s *FilesContext) GetParser() antlr.Parser { return s.parser } + +func (s *FilesContext) FILES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILES, 0) +} + +func (s *FilesContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *FilesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *FilesContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *FilesContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *FilesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *FilesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *FilesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *FilesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FilesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FilesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFiles(s) + } +} + +func (s *FilesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFiles(s) + } +} + +func (s *FilesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFiles(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Files() (localctx IFilesContext) { + localctx = NewFilesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, SnowflakeParserRULE_files) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1398) + p.Match(SnowflakeParserFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1399) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1400) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1401) + p.String_() + } + p.SetState(1406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1402) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1403) + p.String_() + } + + p.SetState(1408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1409) + p.Match(SnowflakeParserRR_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 +} + +// IFile_formatContext is an interface to support dynamic dispatch. +type IFile_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILE_FORMAT() antlr.TerminalNode + EQ() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Format_name() IFormat_nameContext + Format_type() IFormat_typeContext + + // IsFile_formatContext differentiates from other interfaces. + IsFile_formatContext() +} + +type File_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_formatContext() *File_formatContext { + var p = new(File_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_file_format + return p +} + +func InitEmptyFile_formatContext(p *File_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_file_format +} + +func (*File_formatContext) IsFile_formatContext() {} + +func NewFile_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_formatContext { + var p = new(File_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_file_format + + return p +} + +func (s *File_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_formatContext) FILE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE_FORMAT, 0) +} + +func (s *File_formatContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *File_formatContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *File_formatContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *File_formatContext) Format_name() IFormat_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFormat_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFormat_nameContext) +} + +func (s *File_formatContext) Format_type() IFormat_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFormat_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFormat_typeContext) +} + +func (s *File_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFile_format(s) + } +} + +func (s *File_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFile_format(s) + } +} + +func (s *File_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFile_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) File_format() (localctx IFile_formatContext) { + localctx = NewFile_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, SnowflakeParserRULE_file_format) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1411) + p.Match(SnowflakeParserFILE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1412) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1413) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserFORMAT_NAME: + { + p.SetState(1414) + p.Format_name() + } + + case SnowflakeParserTYPE: + { + p.SetState(1415) + p.Format_type() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1418) + p.Match(SnowflakeParserRR_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 +} + +// IFormat_nameContext is an interface to support dynamic dispatch. +type IFormat_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORMAT_NAME() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsFormat_nameContext differentiates from other interfaces. + IsFormat_nameContext() +} + +type Format_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFormat_nameContext() *Format_nameContext { + var p = new(Format_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_format_name + return p +} + +func InitEmptyFormat_nameContext(p *Format_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_format_name +} + +func (*Format_nameContext) IsFormat_nameContext() {} + +func NewFormat_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Format_nameContext { + var p = new(Format_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_format_name + + return p +} + +func (s *Format_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Format_nameContext) FORMAT_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT_NAME, 0) +} + +func (s *Format_nameContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Format_nameContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Format_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Format_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Format_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFormat_name(s) + } +} + +func (s *Format_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFormat_name(s) + } +} + +func (s *Format_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFormat_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Format_name() (localctx IFormat_nameContext) { + localctx = NewFormat_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, SnowflakeParserRULE_format_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1420) + p.Match(SnowflakeParserFORMAT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1421) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1422) + p.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 +} + +// IFormat_typeContext is an interface to support dynamic dispatch. +type IFormat_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TYPE() antlr.TerminalNode + EQ() antlr.TerminalNode + CSV() antlr.TerminalNode + JSON() antlr.TerminalNode + AVRO() antlr.TerminalNode + ORC() antlr.TerminalNode + PARQUET() antlr.TerminalNode + XML() antlr.TerminalNode + AllFormat_type_options() []IFormat_type_optionsContext + Format_type_options(i int) IFormat_type_optionsContext + + // IsFormat_typeContext differentiates from other interfaces. + IsFormat_typeContext() +} + +type Format_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFormat_typeContext() *Format_typeContext { + var p = new(Format_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_format_type + return p +} + +func InitEmptyFormat_typeContext(p *Format_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_format_type +} + +func (*Format_typeContext) IsFormat_typeContext() {} + +func NewFormat_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Format_typeContext { + var p = new(Format_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_format_type + + return p +} + +func (s *Format_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Format_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Format_typeContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Format_typeContext) CSV() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCSV, 0) +} + +func (s *Format_typeContext) JSON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON, 0) +} + +func (s *Format_typeContext) AVRO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVRO, 0) +} + +func (s *Format_typeContext) ORC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORC, 0) +} + +func (s *Format_typeContext) PARQUET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARQUET, 0) +} + +func (s *Format_typeContext) XML() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXML, 0) +} + +func (s *Format_typeContext) AllFormat_type_options() []IFormat_type_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + len++ + } + } + + tst := make([]IFormat_type_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFormat_type_optionsContext); ok { + tst[i] = t.(IFormat_type_optionsContext) + i++ + } + } + + return tst +} + +func (s *Format_typeContext) Format_type_options(i int) IFormat_type_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFormat_type_optionsContext) +} + +func (s *Format_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Format_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Format_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFormat_type(s) + } +} + +func (s *Format_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFormat_type(s) + } +} + +func (s *Format_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFormat_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Format_type() (localctx IFormat_typeContext) { + localctx = NewFormat_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, SnowflakeParserRULE_format_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1424) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1425) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1426) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAVRO || _la == SnowflakeParserCSV || _la == SnowflakeParserJSON || _la == SnowflakeParserORC || _la == SnowflakeParserPARQUET || _la == SnowflakeParserXML) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserALLOW_DUPLICATE || ((int64((_la-97)) & ^0x3f) == 0 && ((int64(1)<<(_la-97))&18437) != 0) || _la == SnowflakeParserCOMPRESSION || _la == SnowflakeParserDATE_FORMAT || ((int64((_la-230)) & ^0x3f) == 0 && ((int64(1)<<(_la-230))&879628696688641) != 0) || ((int64((_la-312)) & ^0x3f) == 0 && ((int64(1)<<(_la-312))&1152925902653358099) != 0) || _la == SnowflakeParserLZO || _la == SnowflakeParserNONE || _la == SnowflakeParserNULL_IF || ((int64((_la-615)) & ^0x3f) == 0 && ((int64(1)<<(_la-615))&1125917086711809) != 0) || _la == SnowflakeParserREPLACE_INVALID_CHARACTERS || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&8070450532247929043) != 0) || ((int64((_la-906)) & ^0x3f) == 0 && ((int64(1)<<(_la-906))&34359746561) != 0) || _la == SnowflakeParserZSTD { + { + p.SetState(1427) + p.Format_type_options() + } + + p.SetState(1432) + 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 +} + +// IStage_file_formatContext is an interface to support dynamic dispatch. +type IStage_file_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STAGE_FILE_FORMAT() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + FORMAT_NAME() antlr.TerminalNode + String_() IStringContext + RR_BRACKET() antlr.TerminalNode + TYPE() antlr.TerminalNode + CSV() antlr.TerminalNode + JSON() antlr.TerminalNode + AVRO() antlr.TerminalNode + ORC() antlr.TerminalNode + PARQUET() antlr.TerminalNode + XML() antlr.TerminalNode + AllFormat_type_options() []IFormat_type_optionsContext + Format_type_options(i int) IFormat_type_optionsContext + + // IsStage_file_formatContext differentiates from other interfaces. + IsStage_file_formatContext() +} + +type Stage_file_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStage_file_formatContext() *Stage_file_formatContext { + var p = new(Stage_file_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_file_format + return p +} + +func InitEmptyStage_file_formatContext(p *Stage_file_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_file_format +} + +func (*Stage_file_formatContext) IsStage_file_formatContext() {} + +func NewStage_file_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stage_file_formatContext { + var p = new(Stage_file_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_stage_file_format + + return p +} + +func (s *Stage_file_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stage_file_formatContext) STAGE_FILE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE_FILE_FORMAT, 0) +} + +func (s *Stage_file_formatContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Stage_file_formatContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Stage_file_formatContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Stage_file_formatContext) FORMAT_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT_NAME, 0) +} + +func (s *Stage_file_formatContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Stage_file_formatContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Stage_file_formatContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Stage_file_formatContext) CSV() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCSV, 0) +} + +func (s *Stage_file_formatContext) JSON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON, 0) +} + +func (s *Stage_file_formatContext) AVRO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVRO, 0) +} + +func (s *Stage_file_formatContext) ORC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORC, 0) +} + +func (s *Stage_file_formatContext) PARQUET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARQUET, 0) +} + +func (s *Stage_file_formatContext) XML() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXML, 0) +} + +func (s *Stage_file_formatContext) AllFormat_type_options() []IFormat_type_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + len++ + } + } + + tst := make([]IFormat_type_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFormat_type_optionsContext); ok { + tst[i] = t.(IFormat_type_optionsContext) + i++ + } + } + + return tst +} + +func (s *Stage_file_formatContext) Format_type_options(i int) IFormat_type_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFormat_type_optionsContext) +} + +func (s *Stage_file_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stage_file_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stage_file_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterStage_file_format(s) + } +} + +func (s *Stage_file_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitStage_file_format(s) + } +} + +func (s *Stage_file_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitStage_file_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Stage_file_format() (localctx IStage_file_formatContext) { + localctx = NewStage_file_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, SnowflakeParserRULE_stage_file_format) + var _la int + + p.SetState(1449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTAGE_FILE_FORMAT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1433) + p.Match(SnowflakeParserSTAGE_FILE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1434) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1435) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(1436) + p.Match(SnowflakeParserFORMAT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1437) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1438) + p.String_() + } + + case SnowflakeParserTYPE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1439) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1440) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1441) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAVRO || _la == SnowflakeParserCSV || _la == SnowflakeParserJSON || _la == SnowflakeParserORC || _la == SnowflakeParserPARQUET || _la == SnowflakeParserXML) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(1443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserALLOW_DUPLICATE || ((int64((_la-97)) & ^0x3f) == 0 && ((int64(1)<<(_la-97))&18437) != 0) || _la == SnowflakeParserCOMPRESSION || _la == SnowflakeParserDATE_FORMAT || ((int64((_la-230)) & ^0x3f) == 0 && ((int64(1)<<(_la-230))&879628696688641) != 0) || ((int64((_la-312)) & ^0x3f) == 0 && ((int64(1)<<(_la-312))&1152925902653358099) != 0) || _la == SnowflakeParserLZO || _la == SnowflakeParserNONE || _la == SnowflakeParserNULL_IF || ((int64((_la-615)) & ^0x3f) == 0 && ((int64(1)<<(_la-615))&1125917086711809) != 0) || _la == SnowflakeParserREPLACE_INVALID_CHARACTERS || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&8070450532247929043) != 0) || ((int64((_la-906)) & ^0x3f) == 0 && ((int64(1)<<(_la-906))&34359746561) != 0) || _la == SnowflakeParserZSTD { + { + p.SetState(1442) + p.Format_type_options() + } + + p.SetState(1445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + { + p.SetState(1447) + p.Match(SnowflakeParserRR_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 +} + +// ICopy_into_locationContext is an interface to support dynamic dispatch. +type ICopy_into_locationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COPY() antlr.TerminalNode + INTO() antlr.TerminalNode + FROM() antlr.TerminalNode + Internal_stage() IInternal_stageContext + External_stage() IExternal_stageContext + External_location() IExternal_locationContext + Object_name() IObject_nameContext + LR_BRACKET() antlr.TerminalNode + Query_statement() IQuery_statementContext + RR_BRACKET() antlr.TerminalNode + Partition_by() IPartition_byContext + File_format() IFile_formatContext + Copy_options() ICopy_optionsContext + VALIDATION_MODE() antlr.TerminalNode + EQ() antlr.TerminalNode + RETURN_ROWS() antlr.TerminalNode + HEADER() antlr.TerminalNode + + // IsCopy_into_locationContext differentiates from other interfaces. + IsCopy_into_locationContext() +} + +type Copy_into_locationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_into_locationContext() *Copy_into_locationContext { + var p = new(Copy_into_locationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_copy_into_location + return p +} + +func InitEmptyCopy_into_locationContext(p *Copy_into_locationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_copy_into_location +} + +func (*Copy_into_locationContext) IsCopy_into_locationContext() {} + +func NewCopy_into_locationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_into_locationContext { + var p = new(Copy_into_locationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_copy_into_location + + return p +} + +func (s *Copy_into_locationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_into_locationContext) COPY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY, 0) +} + +func (s *Copy_into_locationContext) INTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTO, 0) +} + +func (s *Copy_into_locationContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Copy_into_locationContext) Internal_stage() IInternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInternal_stageContext) +} + +func (s *Copy_into_locationContext) External_stage() IExternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_stageContext) +} + +func (s *Copy_into_locationContext) External_location() IExternal_locationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_locationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_locationContext) +} + +func (s *Copy_into_locationContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Copy_into_locationContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Copy_into_locationContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *Copy_into_locationContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Copy_into_locationContext) Partition_by() IPartition_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_byContext) +} + +func (s *Copy_into_locationContext) File_format() IFile_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_formatContext) +} + +func (s *Copy_into_locationContext) 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 *Copy_into_locationContext) VALIDATION_MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALIDATION_MODE, 0) +} + +func (s *Copy_into_locationContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Copy_into_locationContext) RETURN_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_ROWS, 0) +} + +func (s *Copy_into_locationContext) HEADER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHEADER, 0) +} + +func (s *Copy_into_locationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_into_locationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_into_locationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCopy_into_location(s) + } +} + +func (s *Copy_into_locationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCopy_into_location(s) + } +} + +func (s *Copy_into_locationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCopy_into_location(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Copy_into_location() (localctx ICopy_into_locationContext) { + localctx = NewCopy_into_locationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, SnowflakeParserRULE_copy_into_location) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1451) + p.Match(SnowflakeParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1452) + p.Match(SnowflakeParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 52, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1453) + p.Internal_stage() + } + + case 2: + { + p.SetState(1454) + p.External_stage() + } + + case 3: + { + p.SetState(1455) + p.External_location() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(1458) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAAD_PROVISIONER_Q, SnowflakeParserABORT, SnowflakeParserABORT_AFTER_WAIT, SnowflakeParserABORT_DETACHED_QUERY, SnowflakeParserABORT_STATEMENT, SnowflakeParserABSENT, SnowflakeParserABSOLUTE, SnowflakeParserACCESS, SnowflakeParserACCOUNTADMIN, SnowflakeParserACCOUNTS, SnowflakeParserACTION, SnowflakeParserACTIVE, SnowflakeParserADD, SnowflakeParserADMINISTER, SnowflakeParserADMIN_NAME, SnowflakeParserADMIN_PASSWORD, SnowflakeParserAES, SnowflakeParserAFTER, SnowflakeParserAGGREGATE, SnowflakeParserALERT, SnowflakeParserALERTS, SnowflakeParserALLOWED, SnowflakeParserALLOWED_ACCOUNTS, SnowflakeParserALLOWED_DATABASES, SnowflakeParserALLOWED_INTEGRATION_TYPES, SnowflakeParserALLOWED_IP_LIST, SnowflakeParserALLOWED_SHARES, SnowflakeParserALLOWED_VALUES, SnowflakeParserALLOW_CLIENT_MFA_CACHING, SnowflakeParserALLOW_CONNECTIONS, SnowflakeParserALLOW_DUPLICATE, SnowflakeParserALLOW_ID_TOKEN, SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, SnowflakeParserALLOW_OVERLAPPING_EXECUTION, SnowflakeParserALLOW_SINGLE_EVENT_LOSS, SnowflakeParserALWAYS, SnowflakeParserANONYMOUS, SnowflakeParserANSI_DEFAULTS, SnowflakeParserAPI, SnowflakeParserAPI_ALLOWED_PREFIXES, SnowflakeParserAPI_AWS_ROLE_ARN, SnowflakeParserAPI_BLOCKED_PREFIXES, SnowflakeParserAPI_INTEGRATION, SnowflakeParserAPI_KEY, SnowflakeParserAPI_PROVIDER, SnowflakeParserAPPEND, SnowflakeParserAPPEND_ONLY, SnowflakeParserAPPLICATION, SnowflakeParserAPPLY, SnowflakeParserAPP_NAME, SnowflakeParserASC, SnowflakeParserATTACH, SnowflakeParserAT_KEYWORD, SnowflakeParserAUTHORIZATION, SnowflakeParserAUTHORIZATIONS, SnowflakeParserAUTO, SnowflakeParserAUTO_Q, SnowflakeParserAUTOCOMMIT, SnowflakeParserAUTOCOMMIT_API_SUPPORTED, SnowflakeParserAUTOINCREMENT, SnowflakeParserAUTO_COMPRESS, SnowflakeParserAUTO_DETECT, SnowflakeParserAUTO_INGEST, SnowflakeParserAUTO_REFRESH, SnowflakeParserAUTO_RESUME, SnowflakeParserAUTO_SUSPEND, SnowflakeParserAVG, SnowflakeParserAVRO, SnowflakeParserAVRO_Q, SnowflakeParserAWS_KEY_ID, SnowflakeParserAWS_ROLE, SnowflakeParserAWS_SECRET_KEY, SnowflakeParserAWS_SNS, SnowflakeParserAWS_SNS_ROLE_ARN, SnowflakeParserAWS_SNS_TOPIC, SnowflakeParserAWS_SNS_TOPIC_ARN, SnowflakeParserAWS_TOKEN, SnowflakeParserAZURE, SnowflakeParserAZURE_AD_APPLICATION_ID, SnowflakeParserAZURE_EVENT_GRID, SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, SnowflakeParserAZURE_Q, SnowflakeParserAZURE_SAS_TOKEN, SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, SnowflakeParserAZURE_TENANT_ID, SnowflakeParserBEFORE, SnowflakeParserBEGIN, SnowflakeParserBERNOULLI, SnowflakeParserBINARY_AS_TEXT, SnowflakeParserBINARY_CHECKSUM, SnowflakeParserBINARY_FORMAT, SnowflakeParserBINARY_INPUT_FORMAT, SnowflakeParserBINARY_OUTPUT_FORMAT, SnowflakeParserBINDING, SnowflakeParserBLOCK, SnowflakeParserBLOCKED_IP_LIST, SnowflakeParserBLOCKED_ROLES_LIST, SnowflakeParserBODY, SnowflakeParserBOTH_Q, SnowflakeParserBROTLI, SnowflakeParserBUSINESS_CRITICAL, SnowflakeParserCACHE, SnowflakeParserCALL, SnowflakeParserCALLED, SnowflakeParserCALLER, SnowflakeParserCASCADE, SnowflakeParserCASE_INSENSITIVE, SnowflakeParserCASE_SENSITIVE, SnowflakeParserCATCH, SnowflakeParserCERTIFICATE, SnowflakeParserCHANGE, SnowflakeParserCHANGES, SnowflakeParserCHANGETABLE, SnowflakeParserCHANGE_RETENTION, SnowflakeParserCHANGE_TRACKING, SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserCHARINDEX, SnowflakeParserCHECKSUM, SnowflakeParserCHECKSUM_AGG, SnowflakeParserCHECK_EXPIRATION, SnowflakeParserCHECK_POLICY, SnowflakeParserCLASSIFIER_FUNCTION, SnowflakeParserCLEANUP, SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, SnowflakeParserCLIENT_MEMORY_LIMIT, SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, SnowflakeParserCLIENT_PREFETCH_THREADS, SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, SnowflakeParserCLONE, SnowflakeParserCLOSE, SnowflakeParserCLUSTER, SnowflakeParserCLUSTERED, SnowflakeParserCLUSTERING, SnowflakeParserCOALESCE, SnowflakeParserCOLLATE, SnowflakeParserCOLLECTION, SnowflakeParserCOLUMNS, SnowflakeParserCOL_LENGTH, SnowflakeParserCOL_NAME, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOMMITTED, SnowflakeParserCOMPRESS, SnowflakeParserCOMPRESSION, SnowflakeParserCONCAT, SnowflakeParserCONCAT_NULL_YIELDS_NULL, SnowflakeParserCONCAT_WS, SnowflakeParserCONDITION, SnowflakeParserCONFIGURATION, SnowflakeParserCONNECTIONS, SnowflakeParserCONTAINMENT, SnowflakeParserCONTAINS, SnowflakeParserCONTENT, SnowflakeParserCONTEXT, SnowflakeParserCONTEXT_HEADERS, SnowflakeParserCONTEXT_INFO, SnowflakeParserCONTINUE, SnowflakeParserCONTROL, SnowflakeParserCONVERSATION, SnowflakeParserCOOKIE, SnowflakeParserCOPY, SnowflakeParserCOPY_ONLY, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserCOUNT, SnowflakeParserCOUNT_BIG, SnowflakeParserCREDENTIALS, SnowflakeParserCREDIT_QUOTA, SnowflakeParserCSV, SnowflakeParserCSV_Q, SnowflakeParserCUBE, SnowflakeParserCUME_DIST, SnowflakeParserCURRENT_DATE, SnowflakeParserCURRENT_TIMESTAMP, SnowflakeParserCURSOR, SnowflakeParserCUSTOM, SnowflakeParserDAILY, SnowflakeParserDATA, SnowflakeParserDATABASES, SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, SnowflakeParserDATEADD, SnowflakeParserDATEDIFF, SnowflakeParserDATENAME, SnowflakeParserDATEPART, SnowflakeParserDATE_FORMAT, SnowflakeParserDATE_INPUT_FORMAT, SnowflakeParserDATE_OUTPUT_FORMAT, SnowflakeParserDATE_PART, SnowflakeParserDAYS, SnowflakeParserDAYS_TO_EXPIRY, SnowflakeParserDECLARE, SnowflakeParserDEFAULT, SnowflakeParserDEFAULT_DDL_COLLATION_, SnowflakeParserDEFAULT_NAMESPACE, SnowflakeParserDEFAULT_ROLE, SnowflakeParserDEFAULT_WAREHOUSE, SnowflakeParserDEFERRABLE, SnowflakeParserDEFERRED, SnowflakeParserDEFINE, SnowflakeParserDEFINITION, SnowflakeParserDEFLATE, SnowflakeParserDELEGATED, SnowflakeParserDELTA, SnowflakeParserDENSE_RANK, SnowflakeParserDESC, SnowflakeParserDESCRIBE, SnowflakeParserDIRECTION, SnowflakeParserDIRECTORY, SnowflakeParserDISABLE, SnowflakeParserDISABLED, SnowflakeParserDISABLE_AUTO_CONVERT, SnowflakeParserDISABLE_SNOWFLAKE_DATA, SnowflakeParserDISK, SnowflakeParserDISPLAY_NAME, SnowflakeParserDO, SnowflakeParserDOWNSTREAM, SnowflakeParserDOUBLE, SnowflakeParserDYNAMIC, SnowflakeParserECONOMY, SnowflakeParserEDITION, SnowflakeParserEMAIL, SnowflakeParserEMPTY_, SnowflakeParserEMPTY_FIELD_AS_NULL, SnowflakeParserENABLE, SnowflakeParserENABLED, SnowflakeParserENABLE_FOR_PRIVILEGE, SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, SnowflakeParserENABLE_OCTAL, SnowflakeParserENABLE_QUERY_ACCELERATION, SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, SnowflakeParserENCODING, SnowflakeParserENCRYPTION, SnowflakeParserEND, SnowflakeParserENDPOINT, SnowflakeParserEND_TIMESTAMP, SnowflakeParserENFORCED, SnowflakeParserENFORCE_LENGTH, SnowflakeParserENFORCE_SESSION_POLICY, SnowflakeParserENTERPRISE, SnowflakeParserEQUALITY, SnowflakeParserERROR_INTEGRATION, SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, SnowflakeParserESCAPE, SnowflakeParserESCAPE_UNENCLOSED_FIELD, SnowflakeParserEXCEPT, SnowflakeParserEXCHANGE, SnowflakeParserEXECUTE, SnowflakeParserEXECUTION, SnowflakeParserEXIST, SnowflakeParserEXIT, SnowflakeParserEXPAND, SnowflakeParserEXPIRY_DATE, SnowflakeParserEXPLAIN, SnowflakeParserEXPLICIT, SnowflakeParserEXTERNAL, SnowflakeParserEXTERNAL_OAUTH, SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ISSUER, SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, SnowflakeParserEXTERNAL_OAUTH_TYPE, SnowflakeParserEXTERNAL_STAGE, SnowflakeParserFAILOVER, SnowflakeParserFAILOVER_MODE, SnowflakeParserFAIL_OPERATION, SnowflakeParserFETCH, SnowflakeParserFIELD_DELIMITER, SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, SnowflakeParserFILE, SnowflakeParserFILES, SnowflakeParserFILE_EXTENSION, SnowflakeParserFILE_FORMAT, SnowflakeParserFILTER, SnowflakeParserFIRST, SnowflakeParserFIRST_NAME, SnowflakeParserFLATTEN, SnowflakeParserFORCE, SnowflakeParserFOREIGN, SnowflakeParserFORMAT, SnowflakeParserFORMATS, SnowflakeParserFORMAT_NAME, SnowflakeParserFREQUENCY, SnowflakeParserFUNCTION, SnowflakeParserFUNCTIONS, SnowflakeParserFUTURE, SnowflakeParserGCP_PUBSUB, SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, SnowflakeParserGCP_PUBSUB_TOPIC_NAME, SnowflakeParserGCS, SnowflakeParserGENERIC_Q, SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, SnowflakeParserGEO, SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, SnowflakeParserGEOMETRY_OUTPUT_FORMAT, SnowflakeParserGET, SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, SnowflakeParserGLOBAL, SnowflakeParserGOOGLE_AUDIENCE, SnowflakeParserGOTO, SnowflakeParserGRANTS, SnowflakeParserGROUPING, SnowflakeParserGROUPING_ID, SnowflakeParserGROUPS, SnowflakeParserGZIP, SnowflakeParserHEADER, SnowflakeParserHEADERS, SnowflakeParserHEX, SnowflakeParserHIERARCHYID, SnowflakeParserHIGH, SnowflakeParserHISTORY, SnowflakeParserHOURS, SnowflakeParserIDENTITY, SnowflakeParserIF, SnowflakeParserIFF, SnowflakeParserIFNULL, SnowflakeParserIGNORE, SnowflakeParserIGNORE_CONSTRAINTS, SnowflakeParserIGNORE_DUP_KEY, SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, SnowflakeParserIGNORE_TRIGGERS, SnowflakeParserIMMEDIATE, SnowflakeParserIMMEDIATELY, SnowflakeParserIMMUTABLE, SnowflakeParserIMPLICIT, SnowflakeParserIMPORT, SnowflakeParserIMPORTED, SnowflakeParserINDEX, SnowflakeParserINFORMATION, SnowflakeParserINIT, SnowflakeParserINITIALLY, SnowflakeParserINITIALLY_SUSPENDED, SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, SnowflakeParserINPUT, SnowflakeParserINSERT_ONLY, SnowflakeParserINSTEAD, SnowflakeParserINT, SnowflakeParserINTEGRATION, SnowflakeParserINTEGRATIONS, SnowflakeParserISNULL, SnowflakeParserISNUMERIC, SnowflakeParserISOLATION, SnowflakeParserJAVASCRIPT, SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, SnowflakeParserJDBC_USE_SESSION_TIMEZONE, SnowflakeParserJSON, SnowflakeParserJSON_Q, SnowflakeParserJSON_INDENT, SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, SnowflakeParserKB, SnowflakeParserKEEP, SnowflakeParserKEY, SnowflakeParserKEYS, SnowflakeParserKEYSET, SnowflakeParserKMS_KEY_ID, SnowflakeParserLAG, SnowflakeParserLANGUAGE, SnowflakeParserLARGE, SnowflakeParserLAST, SnowflakeParserLAST_NAME, SnowflakeParserLAST_QUERY_ID, SnowflakeParserLAST_VALUE, SnowflakeParserLEAD, SnowflakeParserLEN, SnowflakeParserLENGTH, SnowflakeParserLEVEL, SnowflakeParserLIMIT, SnowflakeParserLINENO, SnowflakeParserLIST, SnowflakeParserLISTENER_IP, SnowflakeParserLISTENER_PORT, SnowflakeParserLISTING, SnowflakeParserLOAD, SnowflakeParserLOCAL, SnowflakeParserLOCAL_SERVICE_NAME, SnowflakeParserLOCATION, SnowflakeParserLOCKS, SnowflakeParserLOCK_TIMEOUT, SnowflakeParserLOG, SnowflakeParserLOGIN, SnowflakeParserLOGIN_NAME, SnowflakeParserLOOKER, SnowflakeParserLOW, SnowflakeParserLOWER, SnowflakeParserLTRIM, SnowflakeParserLZO, SnowflakeParserMANAGE, SnowflakeParserMANAGED, SnowflakeParserMASK, SnowflakeParserMASKED, SnowflakeParserMASKING, SnowflakeParserMASTER, SnowflakeParserMASTER_KEY, SnowflakeParserMATCH, SnowflakeParserMATCHED, SnowflakeParserMATCHES, SnowflakeParserMATCH_BY_COLUMN_NAME, SnowflakeParserMATCH_RECOGNIZE, SnowflakeParserMATERIALIZED, SnowflakeParserMAX_BATCH_ROWS, SnowflakeParserMAX_CLUSTER_COUNT, SnowflakeParserMAX_CONCURRENCY_LEVEL, SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, SnowflakeParserMAX_SIZE, SnowflakeParserMEASURES, SnowflakeParserMEDIUM, SnowflakeParserMEMOIZABLE, SnowflakeParserMERGE, SnowflakeParserMIDDLE_NAME, SnowflakeParserMIN, SnowflakeParserMINS_TO_BYPASS_MFA, SnowflakeParserMINS_TO_UNLOCK, SnowflakeParserMINUS_, SnowflakeParserMINUTES, SnowflakeParserMIN_CLUSTER_COUNT, SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, SnowflakeParserMODE, SnowflakeParserMODIFIED_AFTER, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserMONITORS, SnowflakeParserMONTHLY, SnowflakeParserMOVE, SnowflakeParserMULTI_STATEMENT_COUNT, SnowflakeParserMULTI_USER, SnowflakeParserMUST_CHANGE, SnowflakeParserMUST_CHANGE_PASSWORD, SnowflakeParserNAME, SnowflakeParserNCHAR, SnowflakeParserNESTED_TRIGGERS, SnowflakeParserNETWORK, SnowflakeParserNETWORK_POLICY, SnowflakeParserNEVER, SnowflakeParserNEWID, SnowflakeParserNEWNAME, SnowflakeParserNEWSEQUENTIALID, SnowflakeParserNEW_ACCOUNT, SnowflakeParserNEW_BROKER, SnowflakeParserNEW_PASSWORD, SnowflakeParserNEXT, SnowflakeParserNEXTVAL, SnowflakeParserNO, SnowflakeParserNONE, SnowflakeParserNONE_Q, SnowflakeParserNORELY, SnowflakeParserNOTIFICATION, SnowflakeParserNOTIFICATIONS, SnowflakeParserNOTIFICATION_INTEGRATION, SnowflakeParserNOTIFICATION_PROVIDER, SnowflakeParserNOTIFY, SnowflakeParserNOTIFY_USERS, SnowflakeParserNOVALIDATE, SnowflakeParserNTILE, SnowflakeParserNULLIF, SnowflakeParserNULLS, SnowflakeParserNULL_, SnowflakeParserNULL_IF, SnowflakeParserNUMANODE, SnowflakeParserNUMBER, SnowflakeParserNUMERIC_ROUNDABORT, SnowflakeParserNVL, SnowflakeParserOAUTH, SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, SnowflakeParserOAUTH_CLIENT, SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, SnowflakeParserOAUTH_ENFORCE_PKCE, SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, SnowflakeParserOAUTH_REDIRECT_URI, SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, SnowflakeParserOAUTH_USE_SECONDARY_ROLES, SnowflakeParserOBJECT, SnowflakeParserOBJECT_Q, SnowflakeParserOBJECTS, SnowflakeParserOBJECT_TYPES, SnowflakeParserOFF, SnowflakeParserOFFSET, SnowflakeParserOFFSETS, SnowflakeParserOKTA, SnowflakeParserOKTA_PROVISIONER_Q, SnowflakeParserOKTA_Q, SnowflakeParserOLD, SnowflakeParserOLD_ACCOUNT, SnowflakeParserOLD_PASSWORD, SnowflakeParserOMIT, SnowflakeParserONE, SnowflakeParserONLINE, SnowflakeParserONLY, SnowflakeParserON_ERROR, SnowflakeParserON_FAILURE, SnowflakeParserOPEN, SnowflakeParserOPERATE, SnowflakeParserOPERATIONS, SnowflakeParserOPTIMIZATION, SnowflakeParserOPTION, SnowflakeParserORC, SnowflakeParserORC_Q, SnowflakeParserORGADMIN, SnowflakeParserOUTBOUND, SnowflakeParserOUTER, SnowflakeParserOVER, SnowflakeParserOVERRIDE, SnowflakeParserOVERWRITE, SnowflakeParserOWNER, SnowflakeParserOWNERSHIP, SnowflakeParserPAGE, SnowflakeParserPARALLEL, SnowflakeParserPARAMETERS, SnowflakeParserPARAM_NODE, SnowflakeParserPARQUET, SnowflakeParserPARQUET_Q, SnowflakeParserPARTIAL, SnowflakeParserPARTITION, SnowflakeParserPARTITIONS, SnowflakeParserPARTITION_TYPE, SnowflakeParserPASSWORD, SnowflakeParserPAST, SnowflakeParserPATH_, SnowflakeParserPATTERN, SnowflakeParserPER, SnowflakeParserPERCENT, SnowflakeParserPERCENTILE_CONT, SnowflakeParserPERCENTILE_DISC, SnowflakeParserPERCENT_RANK, SnowflakeParserPERIODIC_DATA_REKEYING, SnowflakeParserPERMISSION_SET, SnowflakeParserPERSISTED, SnowflakeParserPERSIST_SAMPLE_PERCENT, SnowflakeParserPING_FEDERATE, SnowflakeParserPIPE, SnowflakeParserPIPES, SnowflakeParserPIPE_EXECUTION_PAUSED, SnowflakeParserPIVOT, SnowflakeParserPLAN, SnowflakeParserPLATFORM, SnowflakeParserPOLICIES, SnowflakeParserPOLICY, SnowflakeParserPOOL, SnowflakeParserPORT, SnowflakeParserPRECEDING, SnowflakeParserPRECISION, SnowflakeParserPREDICATE, SnowflakeParserPREFIX, SnowflakeParserPRESERVE_SPACE, SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, SnowflakeParserPRIMARY, SnowflakeParserPRIMARY_ROLE, SnowflakeParserPRIOR, SnowflakeParserPRIORITY, SnowflakeParserPRIORITY_LEVEL, SnowflakeParserPRIVATE, SnowflakeParserPRIVATE_KEY, SnowflakeParserPRIVILEGES, SnowflakeParserPROC, SnowflakeParserPROCEDURE, SnowflakeParserPROCEDURES, SnowflakeParserPROCEDURE_NAME, SnowflakeParserPROCESS, SnowflakeParserPROFILE, SnowflakeParserPROPERTY, SnowflakeParserPROVIDER, SnowflakeParserPROVIDER_KEY_NAME, SnowflakeParserPUBLIC, SnowflakeParserPURGE, SnowflakeParserPUT, SnowflakeParserPYTHON, SnowflakeParserQUERIES, SnowflakeParserQUERY, SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, SnowflakeParserQUERY_TAG, SnowflakeParserQUEUE, SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, SnowflakeParserRANGE, SnowflakeParserRANK, SnowflakeParserRAW_DEFLATE, SnowflakeParserREAD, SnowflakeParserREADER, SnowflakeParserREADONLY, SnowflakeParserREADPAST, SnowflakeParserREADTEXT, SnowflakeParserREADWRITE, SnowflakeParserREAD_COMMITTED_SNAPSHOT, SnowflakeParserREAD_ONLY, SnowflakeParserREAD_ONLY_ROUTING_LIST, SnowflakeParserREAD_WRITE, SnowflakeParserREBUILD, SnowflakeParserRECEIVE, SnowflakeParserRECLUSTER, SnowflakeParserRECOMPILE, SnowflakeParserRECONFIGURE, SnowflakeParserRECORD_DELIMITER, SnowflakeParserRECOVERY, SnowflakeParserRECURSIVE, SnowflakeParserRECURSIVE_TRIGGERS, SnowflakeParserREFERENCES, SnowflakeParserREFERENCE_USAGE, SnowflakeParserREFRESH, SnowflakeParserREFRESH_ON_CREATE, SnowflakeParserREGION, SnowflakeParserREGIONS, SnowflakeParserREGION_GROUP, SnowflakeParserRELATIVE, SnowflakeParserRELY, SnowflakeParserREMOTE, SnowflakeParserREMOTE_PROC_TRANSACTIONS, SnowflakeParserREMOTE_SERVICE_NAME, SnowflakeParserREMOVE, SnowflakeParserRENAME, SnowflakeParserREPEATABLE, SnowflakeParserREPLACE, SnowflakeParserREPLACE_INVALID_CHARACTERS, SnowflakeParserREPLICA, SnowflakeParserREPLICATION, SnowflakeParserREPLICATION_SCHEDULE, SnowflakeParserREQUEST_TRANSLATOR, SnowflakeParserREQUIRED, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, SnowflakeParserRESET, SnowflakeParserRESOURCE, SnowflakeParserRESOURCES, SnowflakeParserRESOURCE_MONITOR, SnowflakeParserRESPONSE_TRANSLATOR, SnowflakeParserRESTART, SnowflakeParserRESTORE, SnowflakeParserRESTRICT, SnowflakeParserRESTRICTIONS, SnowflakeParserRESULT, SnowflakeParserRESUME, SnowflakeParserRETAINDAYS, SnowflakeParserRETURN, SnowflakeParserRETURNS, SnowflakeParserRETURN_ALL_ERRORS, SnowflakeParserRETURN_ERRORS, SnowflakeParserRETURN_FAILED_ONLY, SnowflakeParserRETURN_N_ROWS, SnowflakeParserRETURN_ROWS, SnowflakeParserREVERSE, SnowflakeParserREVERT, SnowflakeParserREWIND, SnowflakeParserROLE, SnowflakeParserROLES, SnowflakeParserROLLBACK, SnowflakeParserROLLUP, SnowflakeParserROOT, SnowflakeParserROWCOUNT, SnowflakeParserROWGUID, SnowflakeParserROWLOCK, SnowflakeParserROWS_PER_RESULTSET, SnowflakeParserROW_NUMBER, SnowflakeParserRSA_PUBLIC_KEY, SnowflakeParserRTRIM, SnowflakeParserRUN_AS_ROLE, SnowflakeParserSAFE, SnowflakeParserSAFETY, SnowflakeParserSAML_IDENTITY_PROVIDER, SnowflakeParserSAVE_OLD_URL, SnowflakeParserSCALING_POLICY, SnowflakeParserSCHEDULE, SnowflakeParserSCHEDULER, SnowflakeParserSCHEMAS, SnowflakeParserSCHEME, SnowflakeParserSCIM, SnowflakeParserSCIM_CLIENT, SnowflakeParserSCRIPT, SnowflakeParserSEARCH, SnowflakeParserSECONDARY, SnowflakeParserSECONDARY_ONLY, SnowflakeParserSECONDARY_ROLE, SnowflakeParserSECONDS, SnowflakeParserSECRET, SnowflakeParserSECURE, SnowflakeParserSECURITY, SnowflakeParserSECURITYADMIN, SnowflakeParserSEED, SnowflakeParserSELF, SnowflakeParserSEQUENCE, SnowflakeParserSEQUENCES, SnowflakeParserSERVER, SnowflakeParserSERVICE, SnowflakeParserSESSION, SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, SnowflakeParserSESSION_POLICY, SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, SnowflakeParserSETS, SnowflakeParserSETUSER, SnowflakeParserSHARE, SnowflakeParserSHARED, SnowflakeParserSHARES, SnowflakeParserSHARE_RESTRICTIONS, SnowflakeParserSHOW, SnowflakeParserSHOWPLAN, SnowflakeParserSHOWPLAN_ALL, SnowflakeParserSHOWPLAN_TEXT, SnowflakeParserSHOWPLAN_XML, SnowflakeParserSHOW_INITIAL_ROWS, SnowflakeParserSIGNATURE, SnowflakeParserSIMPLE, SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, SnowflakeParserSINGLE_USER, SnowflakeParserSIZE, SnowflakeParserSIZE_LIMIT, SnowflakeParserSKIP_, SnowflakeParserSKIP_BLANK_LINES, SnowflakeParserSKIP_BYTE_ORDER_MARK, SnowflakeParserSKIP_FILE, SnowflakeParserSKIP_FILE_N, SnowflakeParserSKIP_HEADER, SnowflakeParserSMALL, SnowflakeParserSNAPPY, SnowflakeParserSNAPPY_COMPRESSION, SnowflakeParserSOUNDEX, SnowflakeParserSOURCE, SnowflakeParserSOURCE_COMPRESSION, SnowflakeParserSPACE_KEYWORD, SnowflakeParserSPARSE, SnowflakeParserSPECIFICATION, SnowflakeParserSPLIT, SnowflakeParserSPLIT_PART, SnowflakeParserSQL, SnowflakeParserSSO_LOGIN_PAGE, SnowflakeParserSTAGE, SnowflakeParserSTAGES, SnowflakeParserSTAGE_COPY_OPTIONS, SnowflakeParserSTAGE_FILE_FORMAT, SnowflakeParserSTANDARD, SnowflakeParserSTANDBY, SnowflakeParserSTARTED, SnowflakeParserSTARTS, SnowflakeParserSTART_DATE, SnowflakeParserSTART_TIMESTAMP, SnowflakeParserSTATE, SnowflakeParserSTATEMENT, SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, SnowflakeParserSTATIC, SnowflakeParserSTATISTICS, SnowflakeParserSTATS, SnowflakeParserSTATS_DATE, SnowflakeParserSTATS_STREAM, SnowflakeParserSTATUS, SnowflakeParserSTATUSONLY, SnowflakeParserSTDEV, SnowflakeParserSTDEVP, SnowflakeParserSTOP, SnowflakeParserSTOPLIST, SnowflakeParserSTOPPED, SnowflakeParserSTORAGE, SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, SnowflakeParserSTORAGE_AWS_OBJECT_ACL, SnowflakeParserSTORAGE_AWS_ROLE_ARN, SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, SnowflakeParserSTORAGE_INTEGRATION, SnowflakeParserSTORAGE_PROVIDER, SnowflakeParserSTR, SnowflakeParserSTREAM, SnowflakeParserSTREAMS, SnowflakeParserSTRICT, SnowflakeParserSTRICT_JSON_OUTPUT, SnowflakeParserSTRING_AGG, SnowflakeParserSTRING_ESCAPE, SnowflakeParserSTRIP_NULL_VALUES, SnowflakeParserSTRIP_OUTER_ARRAY, SnowflakeParserSTRIP_OUTER_ELEMENT, SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING, SnowflakeParserSUM, SnowflakeParserSUPPORTED, SnowflakeParserSUSPEND, SnowflakeParserSUSPENDED, SnowflakeParserSUSPEND_IMMEDIATE, SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, SnowflakeParserSWAP, SnowflakeParserSWITCH, SnowflakeParserSYNC_PASSWORD, SnowflakeParserSYSADMIN, SnowflakeParserSYSTEM, SnowflakeParserSYSTEM_USER, SnowflakeParserTABLEAU_DESKTOP, SnowflakeParserTABLEAU_SERVER, SnowflakeParserTABLES, SnowflakeParserTABLE_FORMAT, SnowflakeParserTABULAR, SnowflakeParserTAG, SnowflakeParserTAGS, SnowflakeParserTARGET, SnowflakeParserTARGET_LAG, SnowflakeParserTASK, SnowflakeParserTASKS, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserTERSE, SnowflakeParserTEXTSIZE, SnowflakeParserTIES, SnowflakeParserTIME, SnowflakeParserTIMEADD, SnowflakeParserTIMEDIFF, SnowflakeParserTIMEOUT, SnowflakeParserTIMER, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_FORMAT, SnowflakeParserTIMESTAMP_INPUT_FORMAT, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_TYPE_MAPPING, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMPADD, SnowflakeParserTIMESTAMPDIFF, SnowflakeParserTIMEZONE, SnowflakeParserTIME_FORMAT, SnowflakeParserTIME_INPUT_FORMAT, SnowflakeParserTIME_OUTPUT_FORMAT, SnowflakeParserTO_BOOLEAN, SnowflakeParserTO_DATE, SnowflakeParserTOP, SnowflakeParserTORN_PAGE_DETECTION, SnowflakeParserTRACKING, SnowflakeParserTRACK_CAUSALITY, SnowflakeParserTRAN, SnowflakeParserTRANSACTION, SnowflakeParserTRANSACTIONS, SnowflakeParserTRANSACTION_ABORT_ON_ERROR, SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, SnowflakeParserTRANSACTION_ID, SnowflakeParserTRANSFORM_NOISE_WORDS, SnowflakeParserTRANSIENT, SnowflakeParserTRANSLATE, SnowflakeParserTRIGGERS, SnowflakeParserTRIM, SnowflakeParserTRIM_SPACE, SnowflakeParserTRIPLE_DES, SnowflakeParserTRUNCATE, SnowflakeParserTRUNCATECOLUMNS, SnowflakeParserTRUSTWORTHY, SnowflakeParserTRY, SnowflakeParserTSEQUAL, SnowflakeParserTSQL, SnowflakeParserTWO_DIGIT_CENTURY_START, SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, SnowflakeParserTYPE, SnowflakeParserTYPEPROPERTY, SnowflakeParserTYPE_ID, SnowflakeParserTYPE_NAME, SnowflakeParserTYPE_WARNING, SnowflakeParserUN, SnowflakeParserUNBOUNDED, SnowflakeParserUNCHECKED, SnowflakeParserUNCOMMITTED, SnowflakeParserUNDROP, SnowflakeParserUNICODE, SnowflakeParserUNKNOWN, SnowflakeParserUNLIMITED, SnowflakeParserUNLOCK, SnowflakeParserUNMASK, SnowflakeParserUNMATCHED, SnowflakeParserUNPIVOT, SnowflakeParserUNSAFE, SnowflakeParserUNSET, SnowflakeParserUNSUPPORTED_DDL_ACTION, SnowflakeParserUOW, SnowflakeParserUPDLOCK, SnowflakeParserUPPER, SnowflakeParserURL, SnowflakeParserUSAGE, SnowflakeParserUSE, SnowflakeParserUSED, SnowflakeParserUSER, SnowflakeParserUSERADMIN, SnowflakeParserUSERS, SnowflakeParserUSER_SPECIFIED, SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, SnowflakeParserUSER_TASK_TIMEOUT_MS, SnowflakeParserUSE_ANY_ROLE, SnowflakeParserUSE_CACHED_RESULT, SnowflakeParserVALIDATE, SnowflakeParserVALIDATION, SnowflakeParserVALIDATION_MODE, SnowflakeParserVALID_XML, SnowflakeParserVALUE, SnowflakeParserVAR, SnowflakeParserVARIABLES, SnowflakeParserVARP, SnowflakeParserVARYING, SnowflakeParserVERSION, SnowflakeParserVIEWS, SnowflakeParserVIEW_METADATA, SnowflakeParserVISIBILITY, SnowflakeParserVOLATILE, SnowflakeParserWAIT, SnowflakeParserWAREHOUSE, SnowflakeParserWAREHOUSES, SnowflakeParserWAREHOUSE_SIZE, SnowflakeParserWEEKLY, SnowflakeParserWEEK_OF_YEAR_POLICY, SnowflakeParserWEEK_START, SnowflakeParserWELL_FORMED_XML, SnowflakeParserWITHIN, SnowflakeParserWITHOUT, SnowflakeParserWITHOUT_ARRAY_WRAPPER, SnowflakeParserWORK, SnowflakeParserWORKLOAD, SnowflakeParserWRITE, SnowflakeParserXLARGE, SnowflakeParserXLOCK, SnowflakeParserXML, SnowflakeParserXML_Q, SnowflakeParserXSMALL, SnowflakeParserXXLARGE, SnowflakeParserXXXLARGE, SnowflakeParserYEARLY, SnowflakeParserZSTD, SnowflakeParserARRAY, SnowflakeParserARRAY_Q, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserCHAR_VARYING, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNCHAR_VARYING, SnowflakeParserNUMERIC, SnowflakeParserNVARCHAR, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT, SnowflakeParserLISTAGG, SnowflakeParserDUMMY, SnowflakeParserDOUBLE_QUOTE_ID, SnowflakeParserDOUBLE_QUOTE_BLANK, SnowflakeParserID, SnowflakeParserID2: + { + p.SetState(1459) + p.Object_name() + } + + case SnowflakeParserLR_BRACKET: + { + p.SetState(1460) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1461) + p.Query_statement() + } + { + p.SetState(1462) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(1467) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPARTITION { + { + p.SetState(1466) + p.Partition_by() + } + + } + p.SetState(1470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILE_FORMAT { + { + p.SetState(1469) + p.File_format() + } + + } + p.SetState(1473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASE_INSENSITIVE || _la == SnowflakeParserENFORCE_LENGTH || _la == SnowflakeParserFORCE || _la == SnowflakeParserMATCH_BY_COLUMN_NAME || _la == SnowflakeParserNONE || _la == SnowflakeParserON_ERROR || _la == SnowflakeParserPURGE || _la == SnowflakeParserRETURN_FAILED_ONLY || _la == SnowflakeParserSIZE_LIMIT || _la == SnowflakeParserTRUNCATECOLUMNS { + { + p.SetState(1472) + p.Copy_options() + } + + } + p.SetState(1478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserVALIDATION_MODE { + { + p.SetState(1475) + p.Match(SnowflakeParserVALIDATION_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1476) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1477) + p.Match(SnowflakeParserRETURN_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(1481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserHEADER { + { + p.SetState(1480) + p.Match(SnowflakeParserHEADER) + 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 +} + +// ICommentContext is an interface to support dynamic dispatch. +type ICommentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + ON() antlr.TerminalNode + Object_type_name() IObject_type_nameContext + Object_name() IObject_nameContext + IS() antlr.TerminalNode + String_() IStringContext + If_exists() IIf_existsContext + COLUMN() antlr.TerminalNode + Full_column_name() IFull_column_nameContext + + // IsCommentContext differentiates from other interfaces. + IsCommentContext() +} + +type CommentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommentContext() *CommentContext { + var p = new(CommentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_comment + return p +} + +func InitEmptyCommentContext(p *CommentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_comment +} + +func (*CommentContext) IsCommentContext() {} + +func NewCommentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommentContext { + var p = new(CommentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_comment + + return p +} + +func (s *CommentContext) GetParser() antlr.Parser { return s.parser } + +func (s *CommentContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *CommentContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *CommentContext) 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 *CommentContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *CommentContext) IS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIS, 0) +} + +func (s *CommentContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *CommentContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *CommentContext) COLUMN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMN, 0) +} + +func (s *CommentContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *CommentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CommentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CommentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterComment(s) + } +} + +func (s *CommentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitComment(s) + } +} + +func (s *CommentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitComment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Comment() (localctx ICommentContext) { + localctx = NewCommentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, SnowflakeParserRULE_comment) + var _la int + + p.SetState(1503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 61, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1483) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIF { + { + p.SetState(1484) + p.If_exists() + } + + } + { + p.SetState(1487) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1488) + p.Object_type_name() + } + { + p.SetState(1489) + p.Object_name() + } + { + p.SetState(1490) + p.Match(SnowflakeParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1491) + p.String_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1493) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIF { + { + p.SetState(1494) + p.If_exists() + } + + } + { + p.SetState(1497) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1498) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1499) + p.Full_column_name() + } + { + p.SetState(1500) + p.Match(SnowflakeParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1501) + p.String_() + } + + 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 +} + +// ICommitContext is an interface to support dynamic dispatch. +type ICommitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMIT() antlr.TerminalNode + WORK() antlr.TerminalNode + + // IsCommitContext differentiates from other interfaces. + IsCommitContext() +} + +type CommitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommitContext() *CommitContext { + var p = new(CommitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_commit + return p +} + +func InitEmptyCommitContext(p *CommitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_commit +} + +func (*CommitContext) IsCommitContext() {} + +func NewCommitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CommitContext { + var p = new(CommitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_commit + + return p +} + +func (s *CommitContext) GetParser() antlr.Parser { return s.parser } + +func (s *CommitContext) COMMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMIT, 0) +} + +func (s *CommitContext) WORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWORK, 0) +} + +func (s *CommitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CommitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CommitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCommit(s) + } +} + +func (s *CommitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCommit(s) + } +} + +func (s *CommitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCommit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Commit() (localctx ICommitContext) { + localctx = NewCommitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, SnowflakeParserRULE_commit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1505) + p.Match(SnowflakeParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWORK { + { + p.SetState(1506) + p.Match(SnowflakeParserWORK) + 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 +} + +// IExecute_immediateContext is an interface to support dynamic dispatch. +type IExecute_immediateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + String_() IStringContext + USING() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ID2() antlr.TerminalNode + + // IsExecute_immediateContext differentiates from other interfaces. + IsExecute_immediateContext() +} + +type Execute_immediateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_immediateContext() *Execute_immediateContext { + var p = new(Execute_immediateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_execute_immediate + return p +} + +func InitEmptyExecute_immediateContext(p *Execute_immediateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_execute_immediate +} + +func (*Execute_immediateContext) IsExecute_immediateContext() {} + +func NewExecute_immediateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_immediateContext { + var p = new(Execute_immediateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_execute_immediate + + return p +} + +func (s *Execute_immediateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_immediateContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXECUTE, 0) +} + +func (s *Execute_immediateContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMEDIATE, 0) +} + +func (s *Execute_immediateContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Execute_immediateContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *Execute_immediateContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Execute_immediateContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Execute_immediateContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Execute_immediateContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Execute_immediateContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Execute_immediateContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Execute_immediateContext) ID2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserID2, 0) +} + +func (s *Execute_immediateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_immediateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_immediateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExecute_immediate(s) + } +} + +func (s *Execute_immediateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExecute_immediate(s) + } +} + +func (s *Execute_immediateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExecute_immediate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Execute_immediate() (localctx IExecute_immediateContext) { + localctx = NewExecute_immediateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, SnowflakeParserRULE_execute_immediate) + var _la int + + p.SetState(1560) + 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(1509) + p.Match(SnowflakeParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1510) + p.Match(SnowflakeParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1511) + p.String_() + } + p.SetState(1524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(1512) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1513) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1514) + p.Id_() + } + p.SetState(1519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1515) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1516) + p.Id_() + } + + p.SetState(1521) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1522) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1526) + p.Match(SnowflakeParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1527) + p.Match(SnowflakeParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1528) + p.Id_() + } + p.SetState(1541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(1529) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1530) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1531) + p.Id_() + } + p.SetState(1536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1532) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1533) + p.Id_() + } + + p.SetState(1538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1539) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1543) + p.Match(SnowflakeParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1544) + p.Match(SnowflakeParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1545) + p.Match(SnowflakeParserID2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(1546) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1547) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1548) + p.Id_() + } + p.SetState(1553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1549) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1550) + p.Id_() + } + + p.SetState(1555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(1556) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// IExecute_taskContext is an interface to support dynamic dispatch. +type IExecute_taskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + TASK() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsExecute_taskContext differentiates from other interfaces. + IsExecute_taskContext() +} + +type Execute_taskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecute_taskContext() *Execute_taskContext { + var p = new(Execute_taskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_execute_task + return p +} + +func InitEmptyExecute_taskContext(p *Execute_taskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_execute_task +} + +func (*Execute_taskContext) IsExecute_taskContext() {} + +func NewExecute_taskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Execute_taskContext { + var p = new(Execute_taskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_execute_task + + return p +} + +func (s *Execute_taskContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_taskContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXECUTE, 0) +} + +func (s *Execute_taskContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Execute_taskContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Execute_taskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Execute_taskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Execute_taskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExecute_task(s) + } +} + +func (s *Execute_taskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExecute_task(s) + } +} + +func (s *Execute_taskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExecute_task(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Execute_task() (localctx IExecute_taskContext) { + localctx = NewExecute_taskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, SnowflakeParserRULE_execute_task) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1562) + p.Match(SnowflakeParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1563) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1564) + p.Object_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 +} + +// IExplainContext is an interface to support dynamic dispatch. +type IExplainContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPLAIN() antlr.TerminalNode + Sql_command() ISql_commandContext + USING() antlr.TerminalNode + TABULAR() antlr.TerminalNode + JSON() antlr.TerminalNode + TEXT() antlr.TerminalNode + + // IsExplainContext differentiates from other interfaces. + IsExplainContext() +} + +type ExplainContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplainContext() *ExplainContext { + var p = new(ExplainContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_explain + return p +} + +func InitEmptyExplainContext(p *ExplainContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_explain +} + +func (*ExplainContext) IsExplainContext() {} + +func NewExplainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExplainContext { + var p = new(ExplainContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_explain + + return p +} + +func (s *ExplainContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExplainContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXPLAIN, 0) +} + +func (s *ExplainContext) Sql_command() ISql_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_commandContext) +} + +func (s *ExplainContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *ExplainContext) TABULAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABULAR, 0) +} + +func (s *ExplainContext) JSON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON, 0) +} + +func (s *ExplainContext) TEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEXT, 0) +} + +func (s *ExplainContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExplainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExplainContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExplain(s) + } +} + +func (s *ExplainContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExplain(s) + } +} + +func (s *ExplainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExplain(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Explain() (localctx IExplainContext) { + localctx = NewExplainContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, SnowflakeParserRULE_explain) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1566) + p.Match(SnowflakeParserEXPLAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(1567) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1568) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserJSON || _la == SnowflakeParserTABULAR || _la == SnowflakeParserTEXT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(1571) + p.Sql_command() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParallelContext is an interface to support dynamic dispatch. +type IParallelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARALLEL() antlr.TerminalNode + EQ() antlr.TerminalNode + Num() INumContext + + // IsParallelContext differentiates from other interfaces. + IsParallelContext() +} + +type ParallelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParallelContext() *ParallelContext { + var p = new(ParallelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_parallel + return p +} + +func InitEmptyParallelContext(p *ParallelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_parallel +} + +func (*ParallelContext) IsParallelContext() {} + +func NewParallelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParallelContext { + var p = new(ParallelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_parallel + + return p +} + +func (s *ParallelContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParallelContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARALLEL, 0) +} + +func (s *ParallelContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *ParallelContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *ParallelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParallelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParallelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterParallel(s) + } +} + +func (s *ParallelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitParallel(s) + } +} + +func (s *ParallelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitParallel(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Parallel() (localctx IParallelContext) { + localctx = NewParallelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, SnowflakeParserRULE_parallel) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1573) + p.Match(SnowflakeParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1574) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1575) + p.Num() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGet_dmlContext is an interface to support dynamic dispatch. +type IGet_dmlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GET() antlr.TerminalNode + Internal_stage() IInternal_stageContext + FILE_PATH() antlr.TerminalNode + Parallel() IParallelContext + Pattern() IPatternContext + + // IsGet_dmlContext differentiates from other interfaces. + IsGet_dmlContext() +} + +type Get_dmlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGet_dmlContext() *Get_dmlContext { + var p = new(Get_dmlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_get_dml + return p +} + +func InitEmptyGet_dmlContext(p *Get_dmlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_get_dml +} + +func (*Get_dmlContext) IsGet_dmlContext() {} + +func NewGet_dmlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Get_dmlContext { + var p = new(Get_dmlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_get_dml + + return p +} + +func (s *Get_dmlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Get_dmlContext) GET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGET, 0) +} + +func (s *Get_dmlContext) Internal_stage() IInternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInternal_stageContext) +} + +func (s *Get_dmlContext) FILE_PATH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE_PATH, 0) +} + +func (s *Get_dmlContext) Parallel() IParallelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallelContext) +} + +func (s *Get_dmlContext) Pattern() IPatternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPatternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPatternContext) +} + +func (s *Get_dmlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Get_dmlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Get_dmlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGet_dml(s) + } +} + +func (s *Get_dmlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGet_dml(s) + } +} + +func (s *Get_dmlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGet_dml(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Get_dml() (localctx IGet_dmlContext) { + localctx = NewGet_dmlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, SnowflakeParserRULE_get_dml) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1577) + p.Match(SnowflakeParserGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1578) + p.Internal_stage() + } + { + p.SetState(1579) + p.Match(SnowflakeParserFILE_PATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPARALLEL { + { + p.SetState(1580) + p.Parallel() + } + + } + p.SetState(1584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPATTERN { + { + p.SetState(1583) + p.Pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_ownershipContext is an interface to support dynamic dispatch. +type IGrant_ownershipContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + OWNERSHIP() antlr.TerminalNode + TO() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ON() antlr.TerminalNode + FUTURE() antlr.TerminalNode + Object_type_plural() IObject_type_pluralContext + IN() antlr.TerminalNode + CURRENT() antlr.TerminalNode + GRANTS() antlr.TerminalNode + Object_type_name() IObject_type_nameContext + Object_name() IObject_nameContext + ALL() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + REVOKE() antlr.TerminalNode + COPY() antlr.TerminalNode + + // IsGrant_ownershipContext differentiates from other interfaces. + IsGrant_ownershipContext() +} + +type Grant_ownershipContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_ownershipContext() *Grant_ownershipContext { + var p = new(Grant_ownershipContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_grant_ownership + return p +} + +func InitEmptyGrant_ownershipContext(p *Grant_ownershipContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_grant_ownership +} + +func (*Grant_ownershipContext) IsGrant_ownershipContext() {} + +func NewGrant_ownershipContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_ownershipContext { + var p = new(Grant_ownershipContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_grant_ownership + + return p +} + +func (s *Grant_ownershipContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_ownershipContext) GRANT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANT, 0) +} + +func (s *Grant_ownershipContext) OWNERSHIP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOWNERSHIP, 0) +} + +func (s *Grant_ownershipContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Grant_ownershipContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Grant_ownershipContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Grant_ownershipContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Grant_ownershipContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Grant_ownershipContext) FUTURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUTURE, 0) +} + +func (s *Grant_ownershipContext) Object_type_plural() IObject_type_pluralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_pluralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_pluralContext) +} + +func (s *Grant_ownershipContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Grant_ownershipContext) CURRENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCURRENT, 0) +} + +func (s *Grant_ownershipContext) GRANTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANTS, 0) +} + +func (s *Grant_ownershipContext) 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 *Grant_ownershipContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Grant_ownershipContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Grant_ownershipContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Grant_ownershipContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Grant_ownershipContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Grant_ownershipContext) REVOKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREVOKE, 0) +} + +func (s *Grant_ownershipContext) COPY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY, 0) +} + +func (s *Grant_ownershipContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_ownershipContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_ownershipContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGrant_ownership(s) + } +} + +func (s *Grant_ownershipContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGrant_ownership(s) + } +} + +func (s *Grant_ownershipContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGrant_ownership(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Grant_ownership() (localctx IGrant_ownershipContext) { + localctx = NewGrant_ownershipContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, SnowflakeParserRULE_grant_ownership) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1586) + p.Match(SnowflakeParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1587) + p.Match(SnowflakeParserOWNERSHIP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 76, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1588) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATABASE, SnowflakeParserFILE, SnowflakeParserFUNCTION, SnowflakeParserINTEGRATION, SnowflakeParserMASKING, SnowflakeParserNETWORK, SnowflakeParserPIPE, SnowflakeParserPROCEDURE, SnowflakeParserROLE, SnowflakeParserROW, SnowflakeParserSCHEMA, SnowflakeParserSEQUENCE, SnowflakeParserSESSION, SnowflakeParserSTAGE, SnowflakeParserSTREAM, SnowflakeParserTABLE, SnowflakeParserTAG, SnowflakeParserTASK, SnowflakeParserUSER, SnowflakeParserVIEW, SnowflakeParserWAREHOUSE: + { + p.SetState(1589) + p.Object_type_name() + } + { + p.SetState(1590) + p.Object_name() + } + + case SnowflakeParserALL: + { + p.SetState(1592) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1593) + p.Object_type_plural() + } + { + p.SetState(1594) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATABASE: + { + p.SetState(1595) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1596) + p.Id_() + } + + case SnowflakeParserSCHEMA: + { + p.SetState(1597) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1598) + p.Schema_name() + } + + 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 + } + + case 2: + { + p.SetState(1603) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1604) + p.Match(SnowflakeParserFUTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1605) + p.Object_type_plural() + } + { + p.SetState(1606) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATABASE: + { + p.SetState(1607) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1608) + p.Id_() + } + + case SnowflakeParserSCHEMA: + { + p.SetState(1609) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1610) + p.Schema_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(1615) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1616) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1617) + p.Id_() + } + p.SetState(1621) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY || _la == SnowflakeParserREVOKE { + { + p.SetState(1618) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOPY || _la == SnowflakeParserREVOKE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(1619) + p.Match(SnowflakeParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1620) + p.Match(SnowflakeParserGRANTS) + 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 +} + +// IGrant_to_roleContext is an interface to support dynamic dispatch. +type IGrant_to_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGRANT() []antlr.TerminalNode + GRANT(i int) antlr.TerminalNode + TO() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ON() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + Object_name() IObject_nameContext + FUTURE() antlr.TerminalNode + Object_type_plural() IObject_type_pluralContext + IN() antlr.TerminalNode + ROLE() antlr.TerminalNode + WITH() antlr.TerminalNode + OPTION() antlr.TerminalNode + Global_privileges() IGlobal_privilegesContext + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + Account_object_privileges() IAccount_object_privilegesContext + USER() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + MONITOR() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Schema_privileges() ISchema_privilegesContext + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + SCHEMAS() antlr.TerminalNode + Schema_object_privileges() ISchema_object_privilegesContext + Object_type() IObject_typeContext + PRIVILEGES() antlr.TerminalNode + + // IsGrant_to_roleContext differentiates from other interfaces. + IsGrant_to_roleContext() +} + +type Grant_to_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_to_roleContext() *Grant_to_roleContext { + var p = new(Grant_to_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_grant_to_role + return p +} + +func InitEmptyGrant_to_roleContext(p *Grant_to_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_grant_to_role +} + +func (*Grant_to_roleContext) IsGrant_to_roleContext() {} + +func NewGrant_to_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_to_roleContext { + var p = new(Grant_to_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_grant_to_role + + return p +} + +func (s *Grant_to_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_to_roleContext) AllGRANT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserGRANT) +} + +func (s *Grant_to_roleContext) GRANT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANT, i) +} + +func (s *Grant_to_roleContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Grant_to_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Grant_to_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Grant_to_roleContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Grant_to_roleContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Grant_to_roleContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Grant_to_roleContext) FUTURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUTURE, 0) +} + +func (s *Grant_to_roleContext) Object_type_plural() IObject_type_pluralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_pluralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_pluralContext) +} + +func (s *Grant_to_roleContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Grant_to_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Grant_to_roleContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Grant_to_roleContext) OPTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPTION, 0) +} + +func (s *Grant_to_roleContext) Global_privileges() IGlobal_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGlobal_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGlobal_privilegesContext) +} + +func (s *Grant_to_roleContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserALL) +} + +func (s *Grant_to_roleContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, i) +} + +func (s *Grant_to_roleContext) Account_object_privileges() IAccount_object_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccount_object_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccount_object_privilegesContext) +} + +func (s *Grant_to_roleContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Grant_to_roleContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE, 0) +} + +func (s *Grant_to_roleContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Grant_to_roleContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Grant_to_roleContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Grant_to_roleContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Grant_to_roleContext) Schema_privileges() ISchema_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_privilegesContext) +} + +func (s *Grant_to_roleContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Grant_to_roleContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Grant_to_roleContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMAS, 0) +} + +func (s *Grant_to_roleContext) Schema_object_privileges() ISchema_object_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_privilegesContext) +} + +func (s *Grant_to_roleContext) Object_type() IObject_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_typeContext) +} + +func (s *Grant_to_roleContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIVILEGES, 0) +} + +func (s *Grant_to_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_to_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_to_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGrant_to_role(s) + } +} + +func (s *Grant_to_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGrant_to_role(s) + } +} + +func (s *Grant_to_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGrant_to_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Grant_to_role() (localctx IGrant_to_roleContext) { + localctx = NewGrant_to_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, SnowflakeParserRULE_grant_to_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1623) + p.Match(SnowflakeParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 95, p.GetParserRuleContext()) { + case 1: + p.SetState(1629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAPPLY, SnowflakeParserATTACH, SnowflakeParserCREATE, SnowflakeParserEXECUTE, SnowflakeParserIMPORT, SnowflakeParserMANAGE, SnowflakeParserMONITOR, SnowflakeParserOVERRIDE: + { + p.SetState(1624) + p.Global_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(1625) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1626) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1631) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1632) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(1638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCREATE, SnowflakeParserIMPORTED, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserOPERATE, SnowflakeParserUSAGE, SnowflakeParserUSE_ANY_ROLE: + { + p.SetState(1633) + p.Account_object_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(1634) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1635) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1640) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserUSER: + { + p.SetState(1641) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRESOURCE: + { + p.SetState(1642) + p.Match(SnowflakeParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1643) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserWAREHOUSE: + { + p.SetState(1644) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(1645) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserINTEGRATION: + { + p.SetState(1646) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1649) + p.Object_name() + } + + case 3: + p.SetState(1655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD, SnowflakeParserCREATE, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserUSAGE: + { + p.SetState(1650) + p.Schema_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(1651) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1652) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1657) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1665) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSCHEMA: + { + p.SetState(1658) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1659) + p.Schema_name() + } + + case SnowflakeParserALL: + { + p.SetState(1660) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1661) + p.Match(SnowflakeParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1662) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1663) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1664) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + p.SetState(1672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD, SnowflakeParserCREATE, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserUSAGE: + { + p.SetState(1667) + p.Schema_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(1668) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1670) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1669) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1674) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(1675) + p.Match(SnowflakeParserFUTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1676) + p.Match(SnowflakeParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1677) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1678) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1679) + p.Id_() + } + + case 5: + p.SetState(1685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAPPLY, SnowflakeParserDELETE, SnowflakeParserINSERT, SnowflakeParserMONITOR, SnowflakeParserOPERATE, SnowflakeParserREAD, SnowflakeParserREFERENCES, SnowflakeParserSELECT, SnowflakeParserTRUNCATE, SnowflakeParserUPDATE, SnowflakeParserUSAGE: + { + p.SetState(1680) + p.Schema_object_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(1681) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1682) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1687) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT, SnowflakeParserDATABASES, SnowflakeParserINTEGRATIONS, SnowflakeParserNETWORK, SnowflakeParserRESOURCE, SnowflakeParserROLES, SnowflakeParserSHARES, SnowflakeParserUSERS, SnowflakeParserWAREHOUSES: + { + p.SetState(1688) + p.Object_type() + } + { + p.SetState(1689) + p.Object_name() + } + + case SnowflakeParserALL: + { + p.SetState(1691) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1692) + p.Object_type_plural() + } + { + p.SetState(1693) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATABASE: + { + p.SetState(1694) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1695) + p.Id_() + } + + case SnowflakeParserSCHEMA: + { + p.SetState(1696) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1697) + p.Schema_name() + } + + 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 + } + + case 6: + p.SetState(1707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAPPLY, SnowflakeParserDELETE, SnowflakeParserINSERT, SnowflakeParserMONITOR, SnowflakeParserOPERATE, SnowflakeParserREAD, SnowflakeParserREFERENCES, SnowflakeParserSELECT, SnowflakeParserTRUNCATE, SnowflakeParserUPDATE, SnowflakeParserUSAGE: + { + p.SetState(1702) + p.Schema_object_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(1703) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1704) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1709) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1710) + p.Match(SnowflakeParserFUTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1711) + p.Object_type_plural() + } + { + p.SetState(1712) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1717) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATABASE: + { + p.SetState(1713) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1714) + p.Id_() + } + + case SnowflakeParserSCHEMA: + { + p.SetState(1715) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1716) + p.Schema_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(1721) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1723) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 96, p.GetParserRuleContext()) == 1 { + { + p.SetState(1722) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(1725) + p.Id_() + } + p.SetState(1729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(1726) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1727) + p.Match(SnowflakeParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1728) + p.Match(SnowflakeParserOPTION) + 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 +} + +// IGlobal_privilegesContext is an interface to support dynamic dispatch. +type IGlobal_privilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGlobal_privilege() []IGlobal_privilegeContext + Global_privilege(i int) IGlobal_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGlobal_privilegesContext differentiates from other interfaces. + IsGlobal_privilegesContext() +} + +type Global_privilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGlobal_privilegesContext() *Global_privilegesContext { + var p = new(Global_privilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_global_privileges + return p +} + +func InitEmptyGlobal_privilegesContext(p *Global_privilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_global_privileges +} + +func (*Global_privilegesContext) IsGlobal_privilegesContext() {} + +func NewGlobal_privilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Global_privilegesContext { + var p = new(Global_privilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_global_privileges + + return p +} + +func (s *Global_privilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Global_privilegesContext) AllGlobal_privilege() []IGlobal_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGlobal_privilegeContext); ok { + len++ + } + } + + tst := make([]IGlobal_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGlobal_privilegeContext); ok { + tst[i] = t.(IGlobal_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Global_privilegesContext) Global_privilege(i int) IGlobal_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGlobal_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGlobal_privilegeContext) +} + +func (s *Global_privilegesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Global_privilegesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Global_privilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Global_privilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Global_privilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGlobal_privileges(s) + } +} + +func (s *Global_privilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGlobal_privileges(s) + } +} + +func (s *Global_privilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGlobal_privileges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Global_privileges() (localctx IGlobal_privilegesContext) { + localctx = NewGlobal_privilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, SnowflakeParserRULE_global_privileges) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1731) + p.Global_privilege() + } + p.SetState(1736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1732) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1733) + p.Global_privilege() + } + + p.SetState(1738) + 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 +} + +// IGlobal_privilegeContext is an interface to support dynamic dispatch. +type IGlobal_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + DATA() antlr.TerminalNode + EXCHANGE() antlr.TerminalNode + LISTING() antlr.TerminalNode + DATABASE() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + NETWORK() antlr.TerminalNode + POLICY() antlr.TerminalNode + ROLE() antlr.TerminalNode + SHARE() antlr.TerminalNode + USER() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + APPLY() antlr.TerminalNode + MASKING() antlr.TerminalNode + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + SESSION() antlr.TerminalNode + TAG() antlr.TerminalNode + ATTACH() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + TASK() antlr.TerminalNode + IMPORT() antlr.TerminalNode + MANAGE() antlr.TerminalNode + GRANTS() antlr.TerminalNode + MONITOR() antlr.TerminalNode + OVERRIDE() antlr.TerminalNode + RESTRICTIONS() antlr.TerminalNode + EXECUTION() antlr.TerminalNode + USAGE() antlr.TerminalNode + + // IsGlobal_privilegeContext differentiates from other interfaces. + IsGlobal_privilegeContext() +} + +type Global_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGlobal_privilegeContext() *Global_privilegeContext { + var p = new(Global_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_global_privilege + return p +} + +func InitEmptyGlobal_privilegeContext(p *Global_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_global_privilege +} + +func (*Global_privilegeContext) IsGlobal_privilegeContext() {} + +func NewGlobal_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Global_privilegeContext { + var p = new(Global_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_global_privilege + + return p +} + +func (s *Global_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Global_privilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Global_privilegeContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Global_privilegeContext) DATA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA, 0) +} + +func (s *Global_privilegeContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXCHANGE, 0) +} + +func (s *Global_privilegeContext) LISTING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLISTING, 0) +} + +func (s *Global_privilegeContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Global_privilegeContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Global_privilegeContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Global_privilegeContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Global_privilegeContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Global_privilegeContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Global_privilegeContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Global_privilegeContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Global_privilegeContext) APPLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPPLY, 0) +} + +func (s *Global_privilegeContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Global_privilegeContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Global_privilegeContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Global_privilegeContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Global_privilegeContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Global_privilegeContext) ATTACH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserATTACH, 0) +} + +func (s *Global_privilegeContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXECUTE, 0) +} + +func (s *Global_privilegeContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Global_privilegeContext) IMPORT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMPORT, 0) +} + +func (s *Global_privilegeContext) MANAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMANAGE, 0) +} + +func (s *Global_privilegeContext) GRANTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANTS, 0) +} + +func (s *Global_privilegeContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Global_privilegeContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOVERRIDE, 0) +} + +func (s *Global_privilegeContext) RESTRICTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESTRICTIONS, 0) +} + +func (s *Global_privilegeContext) EXECUTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXECUTION, 0) +} + +func (s *Global_privilegeContext) USAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSAGE, 0) +} + +func (s *Global_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Global_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Global_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGlobal_privilege(s) + } +} + +func (s *Global_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGlobal_privilege(s) + } +} + +func (s *Global_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGlobal_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Global_privilege() (localctx IGlobal_privilegeContext) { + localctx = NewGlobal_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, SnowflakeParserRULE_global_privilege) + var _la int + + p.SetState(1783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCREATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1739) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT: + { + p.SetState(1740) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATA: + { + p.SetState(1741) + p.Match(SnowflakeParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1742) + p.Match(SnowflakeParserEXCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1743) + p.Match(SnowflakeParserLISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(1744) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserINTEGRATION: + { + p.SetState(1745) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNETWORK: + { + p.SetState(1746) + p.Match(SnowflakeParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1747) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserROLE: + { + p.SetState(1748) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSHARE: + { + p.SetState(1749) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUSER: + { + p.SetState(1750) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserWAREHOUSE: + { + p.SetState(1751) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case SnowflakeParserAPPLY, SnowflakeParserATTACH: + p.EnterOuterAlt(localctx, 2) + p.SetState(1768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 100, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1754) + p.Match(SnowflakeParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1755) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1756) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(1757) + p.Match(SnowflakeParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1758) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1759) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1760) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(1761) + p.Match(SnowflakeParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1762) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1763) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(1764) + p.Match(SnowflakeParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1765) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(1766) + p.Match(SnowflakeParserATTACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1767) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case SnowflakeParserEXECUTE, SnowflakeParserIMPORT, SnowflakeParserMANAGE, SnowflakeParserMONITOR, SnowflakeParserOVERRIDE: + p.EnterOuterAlt(localctx, 3) + p.SetState(1781) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserEXECUTE: + { + p.SetState(1770) + p.Match(SnowflakeParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1771) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserIMPORT: + { + p.SetState(1772) + p.Match(SnowflakeParserIMPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1773) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserMANAGE: + { + p.SetState(1774) + p.Match(SnowflakeParserMANAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1775) + p.Match(SnowflakeParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserMONITOR: + { + p.SetState(1776) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1777) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserEXECUTION || _la == SnowflakeParserUSAGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserOVERRIDE: + { + p.SetState(1778) + p.Match(SnowflakeParserOVERRIDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1779) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1780) + p.Match(SnowflakeParserRESTRICTIONS) + 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 +} + +// IAccount_object_privilegesContext is an interface to support dynamic dispatch. +type IAccount_object_privilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAccount_object_privilege() []IAccount_object_privilegeContext + Account_object_privilege(i int) IAccount_object_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAccount_object_privilegesContext differentiates from other interfaces. + IsAccount_object_privilegesContext() +} + +type Account_object_privilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccount_object_privilegesContext() *Account_object_privilegesContext { + var p = new(Account_object_privilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_object_privileges + return p +} + +func InitEmptyAccount_object_privilegesContext(p *Account_object_privilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_object_privileges +} + +func (*Account_object_privilegesContext) IsAccount_object_privilegesContext() {} + +func NewAccount_object_privilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Account_object_privilegesContext { + var p = new(Account_object_privilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_account_object_privileges + + return p +} + +func (s *Account_object_privilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Account_object_privilegesContext) AllAccount_object_privilege() []IAccount_object_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAccount_object_privilegeContext); ok { + len++ + } + } + + tst := make([]IAccount_object_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAccount_object_privilegeContext); ok { + tst[i] = t.(IAccount_object_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Account_object_privilegesContext) Account_object_privilege(i int) IAccount_object_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccount_object_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAccount_object_privilegeContext) +} + +func (s *Account_object_privilegesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Account_object_privilegesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Account_object_privilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Account_object_privilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Account_object_privilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAccount_object_privileges(s) + } +} + +func (s *Account_object_privilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAccount_object_privileges(s) + } +} + +func (s *Account_object_privilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAccount_object_privileges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Account_object_privileges() (localctx IAccount_object_privilegesContext) { + localctx = NewAccount_object_privilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, SnowflakeParserRULE_account_object_privileges) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1785) + p.Account_object_privilege() + } + p.SetState(1790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1786) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1787) + p.Account_object_privilege() + } + + p.SetState(1792) + 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 +} + +// IAccount_object_privilegeContext is an interface to support dynamic dispatch. +type IAccount_object_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MONITOR() antlr.TerminalNode + MODIFY() antlr.TerminalNode + USAGE() antlr.TerminalNode + OPERATE() antlr.TerminalNode + CREATE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + IMPORTED() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + USE_ANY_ROLE() antlr.TerminalNode + + // IsAccount_object_privilegeContext differentiates from other interfaces. + IsAccount_object_privilegeContext() +} + +type Account_object_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccount_object_privilegeContext() *Account_object_privilegeContext { + var p = new(Account_object_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_object_privilege + return p +} + +func InitEmptyAccount_object_privilegeContext(p *Account_object_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_object_privilege +} + +func (*Account_object_privilegeContext) IsAccount_object_privilegeContext() {} + +func NewAccount_object_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Account_object_privilegeContext { + var p = new(Account_object_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_account_object_privilege + + return p +} + +func (s *Account_object_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Account_object_privilegeContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Account_object_privilegeContext) MODIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODIFY, 0) +} + +func (s *Account_object_privilegeContext) USAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSAGE, 0) +} + +func (s *Account_object_privilegeContext) OPERATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPERATE, 0) +} + +func (s *Account_object_privilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Account_object_privilegeContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Account_object_privilegeContext) IMPORTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMPORTED, 0) +} + +func (s *Account_object_privilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIVILEGES, 0) +} + +func (s *Account_object_privilegeContext) USE_ANY_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE_ANY_ROLE, 0) +} + +func (s *Account_object_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Account_object_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Account_object_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAccount_object_privilege(s) + } +} + +func (s *Account_object_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAccount_object_privilege(s) + } +} + +func (s *Account_object_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAccount_object_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Account_object_privilege() (localctx IAccount_object_privilegeContext) { + localctx = NewAccount_object_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, SnowflakeParserRULE_account_object_privilege) + p.SetState(1802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserMONITOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1793) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1794) + p.Match(SnowflakeParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUSAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1795) + p.Match(SnowflakeParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserOPERATE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1796) + p.Match(SnowflakeParserOPERATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserCREATE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1797) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1798) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserIMPORTED: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1799) + p.Match(SnowflakeParserIMPORTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1800) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUSE_ANY_ROLE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1801) + p.Match(SnowflakeParserUSE_ANY_ROLE) + 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 +} + +// ISchema_privilegesContext is an interface to support dynamic dispatch. +type ISchema_privilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSchema_privilege() []ISchema_privilegeContext + Schema_privilege(i int) ISchema_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSchema_privilegesContext differentiates from other interfaces. + IsSchema_privilegesContext() +} + +type Schema_privilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_privilegesContext() *Schema_privilegesContext { + var p = new(Schema_privilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_privileges + return p +} + +func InitEmptySchema_privilegesContext(p *Schema_privilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_privileges +} + +func (*Schema_privilegesContext) IsSchema_privilegesContext() {} + +func NewSchema_privilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_privilegesContext { + var p = new(Schema_privilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_schema_privileges + + return p +} + +func (s *Schema_privilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_privilegesContext) AllSchema_privilege() []ISchema_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_privilegeContext); ok { + len++ + } + } + + tst := make([]ISchema_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_privilegeContext); ok { + tst[i] = t.(ISchema_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Schema_privilegesContext) Schema_privilege(i int) ISchema_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_privilegeContext) +} + +func (s *Schema_privilegesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Schema_privilegesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Schema_privilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_privilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_privilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSchema_privileges(s) + } +} + +func (s *Schema_privilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSchema_privileges(s) + } +} + +func (s *Schema_privilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSchema_privileges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Schema_privileges() (localctx ISchema_privilegesContext) { + localctx = NewSchema_privilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, SnowflakeParserRULE_schema_privileges) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1804) + p.Schema_privilege() + } + p.SetState(1809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1805) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1806) + p.Schema_privilege() + } + + p.SetState(1811) + 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 +} + +// ISchema_privilegeContext is an interface to support dynamic dispatch. +type ISchema_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + MONITOR() antlr.TerminalNode + USAGE() antlr.TerminalNode + CREATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + VIEW() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + SESSION() antlr.TerminalNode + TAG() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + STAGE() antlr.TerminalNode + PIPE() antlr.TerminalNode + STREAM() antlr.TerminalNode + TASK() antlr.TerminalNode + ADD() antlr.TerminalNode + SEARCH() antlr.TerminalNode + OPTIMIZATION() antlr.TerminalNode + + // IsSchema_privilegeContext differentiates from other interfaces. + IsSchema_privilegeContext() +} + +type Schema_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_privilegeContext() *Schema_privilegeContext { + var p = new(Schema_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_privilege + return p +} + +func InitEmptySchema_privilegeContext(p *Schema_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_privilege +} + +func (*Schema_privilegeContext) IsSchema_privilegeContext() {} + +func NewSchema_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_privilegeContext { + var p = new(Schema_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_schema_privilege + + return p +} + +func (s *Schema_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_privilegeContext) MODIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODIFY, 0) +} + +func (s *Schema_privilegeContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Schema_privilegeContext) USAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSAGE, 0) +} + +func (s *Schema_privilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Schema_privilegeContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Schema_privilegeContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Schema_privilegeContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Schema_privilegeContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATERIALIZED, 0) +} + +func (s *Schema_privilegeContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Schema_privilegeContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Schema_privilegeContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Schema_privilegeContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Schema_privilegeContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Schema_privilegeContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Schema_privilegeContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 0) +} + +func (s *Schema_privilegeContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Schema_privilegeContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE, 0) +} + +func (s *Schema_privilegeContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Schema_privilegeContext) FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT, 0) +} + +func (s *Schema_privilegeContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Schema_privilegeContext) PIPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE, 0) +} + +func (s *Schema_privilegeContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Schema_privilegeContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Schema_privilegeContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Schema_privilegeContext) SEARCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEARCH, 0) +} + +func (s *Schema_privilegeContext) OPTIMIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPTIMIZATION, 0) +} + +func (s *Schema_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSchema_privilege(s) + } +} + +func (s *Schema_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSchema_privilege(s) + } +} + +func (s *Schema_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSchema_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Schema_privilege() (localctx ISchema_privilegeContext) { + localctx = NewSchema_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, SnowflakeParserRULE_schema_privilege) + p.SetState(1844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserMODIFY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1812) + p.Match(SnowflakeParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserMONITOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1813) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUSAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1814) + p.Match(SnowflakeParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserCREATE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1815) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserTABLE: + { + p.SetState(1816) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserEXTERNAL: + { + p.SetState(1817) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1818) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserVIEW: + { + p.SetState(1819) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserMATERIALIZED: + { + p.SetState(1820) + p.Match(SnowflakeParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1821) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserMASKING: + { + p.SetState(1822) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1823) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserROW: + { + p.SetState(1824) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1825) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1826) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSESSION: + { + p.SetState(1827) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1828) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTAG: + { + p.SetState(1829) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSEQUENCE: + { + p.SetState(1830) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFUNCTION: + { + p.SetState(1831) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserPROCEDURE: + { + p.SetState(1832) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFILE: + { + p.SetState(1833) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1834) + p.Match(SnowflakeParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTAGE: + { + p.SetState(1835) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserPIPE: + { + p.SetState(1836) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTREAM: + { + p.SetState(1837) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTASK: + { + p.SetState(1838) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case SnowflakeParserADD: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1841) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1842) + p.Match(SnowflakeParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1843) + p.Match(SnowflakeParserOPTIMIZATION) + 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 +} + +// ISchema_object_privilegesContext is an interface to support dynamic dispatch. +type ISchema_object_privilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSchema_object_privilege() []ISchema_object_privilegeContext + Schema_object_privilege(i int) ISchema_object_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSchema_object_privilegesContext differentiates from other interfaces. + IsSchema_object_privilegesContext() +} + +type Schema_object_privilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_object_privilegesContext() *Schema_object_privilegesContext { + var p = new(Schema_object_privilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_object_privileges + return p +} + +func InitEmptySchema_object_privilegesContext(p *Schema_object_privilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_object_privileges +} + +func (*Schema_object_privilegesContext) IsSchema_object_privilegesContext() {} + +func NewSchema_object_privilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_object_privilegesContext { + var p = new(Schema_object_privilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_schema_object_privileges + + return p +} + +func (s *Schema_object_privilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_object_privilegesContext) AllSchema_object_privilege() []ISchema_object_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_object_privilegeContext); ok { + len++ + } + } + + tst := make([]ISchema_object_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_object_privilegeContext); ok { + tst[i] = t.(ISchema_object_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Schema_object_privilegesContext) Schema_object_privilege(i int) ISchema_object_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_privilegeContext) +} + +func (s *Schema_object_privilegesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Schema_object_privilegesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Schema_object_privilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_object_privilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_object_privilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSchema_object_privileges(s) + } +} + +func (s *Schema_object_privilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSchema_object_privileges(s) + } +} + +func (s *Schema_object_privilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSchema_object_privileges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Schema_object_privileges() (localctx ISchema_object_privilegesContext) { + localctx = NewSchema_object_privilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, SnowflakeParserRULE_schema_object_privileges) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1846) + p.Schema_object_privilege() + } + p.SetState(1851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(1847) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1848) + p.Schema_object_privilege() + } + + p.SetState(1853) + 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 +} + +// ISchema_object_privilegeContext is an interface to support dynamic dispatch. +type ISchema_object_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + INSERT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + DELETE() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + USAGE() antlr.TerminalNode + READ() antlr.TerminalNode + COMMA() antlr.TerminalNode + WRITE() antlr.TerminalNode + MONITOR() antlr.TerminalNode + OPERATE() antlr.TerminalNode + APPLY() antlr.TerminalNode + + // IsSchema_object_privilegeContext differentiates from other interfaces. + IsSchema_object_privilegeContext() +} + +type Schema_object_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_object_privilegeContext() *Schema_object_privilegeContext { + var p = new(Schema_object_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_object_privilege + return p +} + +func InitEmptySchema_object_privilegeContext(p *Schema_object_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_object_privilege +} + +func (*Schema_object_privilegeContext) IsSchema_object_privilegeContext() {} + +func NewSchema_object_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_object_privilegeContext { + var p = new(Schema_object_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_schema_object_privilege + + return p +} + +func (s *Schema_object_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_object_privilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSELECT, 0) +} + +func (s *Schema_object_privilegeContext) INSERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINSERT, 0) +} + +func (s *Schema_object_privilegeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUPDATE, 0) +} + +func (s *Schema_object_privilegeContext) DELETE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELETE, 0) +} + +func (s *Schema_object_privilegeContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUNCATE, 0) +} + +func (s *Schema_object_privilegeContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFERENCES, 0) +} + +func (s *Schema_object_privilegeContext) USAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSAGE, 0) +} + +func (s *Schema_object_privilegeContext) READ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAD, 0) +} + +func (s *Schema_object_privilegeContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Schema_object_privilegeContext) WRITE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWRITE, 0) +} + +func (s *Schema_object_privilegeContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Schema_object_privilegeContext) OPERATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPERATE, 0) +} + +func (s *Schema_object_privilegeContext) APPLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPPLY, 0) +} + +func (s *Schema_object_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_object_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_object_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSchema_object_privilege(s) + } +} + +func (s *Schema_object_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSchema_object_privilege(s) + } +} + +func (s *Schema_object_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSchema_object_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Schema_object_privilege() (localctx ISchema_object_privilegeContext) { + localctx = NewSchema_object_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, SnowflakeParserRULE_schema_object_privilege) + p.SetState(1869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSELECT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1854) + p.Match(SnowflakeParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserINSERT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1855) + p.Match(SnowflakeParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUPDATE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(1856) + p.Match(SnowflakeParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDELETE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(1857) + p.Match(SnowflakeParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTRUNCATE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(1858) + p.Match(SnowflakeParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserREFERENCES: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(1859) + p.Match(SnowflakeParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUSAGE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(1860) + p.Match(SnowflakeParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserREAD: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(1861) + p.Match(SnowflakeParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1864) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 109, p.GetParserRuleContext()) == 1 { + { + p.SetState(1862) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1863) + p.Match(SnowflakeParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserMONITOR: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(1866) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserOPERATE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(1867) + p.Match(SnowflakeParserOPERATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAPPLY: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(1868) + p.Match(SnowflakeParserAPPLY) + 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 +} + +// IGrant_to_shareContext is an interface to support dynamic dispatch. +type IGrant_to_shareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + Object_privilege() IObject_privilegeContext + ON() antlr.TerminalNode + TO() antlr.TerminalNode + SHARE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + VIEW() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + ALL() antlr.TerminalNode + TABLES() antlr.TerminalNode + IN() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsGrant_to_shareContext differentiates from other interfaces. + IsGrant_to_shareContext() +} + +type Grant_to_shareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_to_shareContext() *Grant_to_shareContext { + var p = new(Grant_to_shareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_grant_to_share + return p +} + +func InitEmptyGrant_to_shareContext(p *Grant_to_shareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_grant_to_share +} + +func (*Grant_to_shareContext) IsGrant_to_shareContext() {} + +func NewGrant_to_shareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_to_shareContext { + var p = new(Grant_to_shareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_grant_to_share + + return p +} + +func (s *Grant_to_shareContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_to_shareContext) GRANT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANT, 0) +} + +func (s *Grant_to_shareContext) Object_privilege() IObject_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_privilegeContext) +} + +func (s *Grant_to_shareContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Grant_to_shareContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Grant_to_shareContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Grant_to_shareContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Grant_to_shareContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Grant_to_shareContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Grant_to_shareContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Grant_to_shareContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Grant_to_shareContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Grant_to_shareContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Grant_to_shareContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Grant_to_shareContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Grant_to_shareContext) TABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLES, 0) +} + +func (s *Grant_to_shareContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Grant_to_shareContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Grant_to_shareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_to_shareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_to_shareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGrant_to_share(s) + } +} + +func (s *Grant_to_shareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGrant_to_share(s) + } +} + +func (s *Grant_to_shareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGrant_to_share(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Grant_to_share() (localctx IGrant_to_shareContext) { + localctx = NewGrant_to_shareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, SnowflakeParserRULE_grant_to_share) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1871) + p.Match(SnowflakeParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1872) + p.Object_privilege() + } + { + p.SetState(1873) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATABASE: + { + p.SetState(1874) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1875) + p.Id_() + } + + case SnowflakeParserSCHEMA: + { + p.SetState(1876) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1877) + p.Id_() + } + + case SnowflakeParserFUNCTION: + { + p.SetState(1878) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1879) + p.Id_() + } + + case SnowflakeParserALL, SnowflakeParserTABLE: + p.SetState(1887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserTABLE: + { + p.SetState(1880) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1881) + p.Object_name() + } + + case SnowflakeParserALL: + { + p.SetState(1882) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1883) + p.Match(SnowflakeParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1884) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1885) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1886) + p.Schema_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case SnowflakeParserVIEW: + { + p.SetState(1889) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1890) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1893) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1894) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1895) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_privilegeContext is an interface to support dynamic dispatch. +type IObject_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USAGE() antlr.TerminalNode + SELECT() antlr.TerminalNode + REFERENCE_USAGE() antlr.TerminalNode + + // IsObject_privilegeContext differentiates from other interfaces. + IsObject_privilegeContext() +} + +type Object_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_privilegeContext() *Object_privilegeContext { + var p = new(Object_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_privilege + return p +} + +func InitEmptyObject_privilegeContext(p *Object_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_privilege +} + +func (*Object_privilegeContext) IsObject_privilegeContext() {} + +func NewObject_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_privilegeContext { + var p = new(Object_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_object_privilege + + return p +} + +func (s *Object_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_privilegeContext) USAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSAGE, 0) +} + +func (s *Object_privilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSELECT, 0) +} + +func (s *Object_privilegeContext) REFERENCE_USAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFERENCE_USAGE, 0) +} + +func (s *Object_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterObject_privilege(s) + } +} + +func (s *Object_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_privilege(s) + } +} + +func (s *Object_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_privilege() (localctx IObject_privilegeContext) { + localctx = NewObject_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, SnowflakeParserRULE_object_privilege) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1897) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserREFERENCE_USAGE || _la == SnowflakeParserSELECT || _la == SnowflakeParserUSAGE) { + 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 +} + +// IGrant_roleContext is an interface to support dynamic dispatch. +type IGrant_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GRANT() antlr.TerminalNode + AllROLE() []antlr.TerminalNode + ROLE(i int) antlr.TerminalNode + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + TO() antlr.TerminalNode + USER() antlr.TerminalNode + Id_() IId_Context + + // IsGrant_roleContext differentiates from other interfaces. + IsGrant_roleContext() +} + +type Grant_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_roleContext() *Grant_roleContext { + var p = new(Grant_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_grant_role + return p +} + +func InitEmptyGrant_roleContext(p *Grant_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_grant_role +} + +func (*Grant_roleContext) IsGrant_roleContext() {} + +func NewGrant_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_roleContext { + var p = new(Grant_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_grant_role + + return p +} + +func (s *Grant_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_roleContext) GRANT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANT, 0) +} + +func (s *Grant_roleContext) AllROLE() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserROLE) +} + +func (s *Grant_roleContext) ROLE(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, i) +} + +func (s *Grant_roleContext) AllRole_name() []IRole_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_nameContext); ok { + len++ + } + } + + tst := make([]IRole_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_nameContext); ok { + tst[i] = t.(IRole_nameContext) + i++ + } + } + + return tst +} + +func (s *Grant_roleContext) Role_name(i int) IRole_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Grant_roleContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Grant_roleContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Grant_roleContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Grant_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGrant_role(s) + } +} + +func (s *Grant_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGrant_role(s) + } +} + +func (s *Grant_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGrant_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Grant_role() (localctx IGrant_roleContext) { + localctx = NewGrant_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, SnowflakeParserRULE_grant_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1899) + p.Match(SnowflakeParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1900) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1901) + p.Role_name() + } + { + p.SetState(1902) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserROLE: + { + p.SetState(1903) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1904) + p.Role_name() + } + + case SnowflakeParserUSER: + { + p.SetState(1905) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1906) + p.Id_() + } + + 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_nameContext is an interface to support dynamic dispatch. +type IRole_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + System_defined_role() ISystem_defined_roleContext + Id_() IId_Context + + // IsRole_nameContext differentiates from other interfaces. + IsRole_nameContext() +} + +type Role_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_nameContext() *Role_nameContext { + var p = new(Role_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_role_name + return p +} + +func InitEmptyRole_nameContext(p *Role_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_role_name +} + +func (*Role_nameContext) IsRole_nameContext() {} + +func NewRole_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_nameContext { + var p = new(Role_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_role_name + + return p +} + +func (s *Role_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_nameContext) System_defined_role() ISystem_defined_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_defined_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_defined_roleContext) +} + +func (s *Role_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Role_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRole_name(s) + } +} + +func (s *Role_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRole_name(s) + } +} + +func (s *Role_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRole_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Role_name() (localctx IRole_nameContext) { + localctx = NewRole_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, SnowflakeParserRULE_role_name) + p.SetState(1911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 114, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1909) + p.System_defined_role() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(1910) + p.Id_() + } + + 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 +} + +// ISystem_defined_roleContext is an interface to support dynamic dispatch. +type ISystem_defined_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORGADMIN() antlr.TerminalNode + ACCOUNTADMIN() antlr.TerminalNode + SECURITYADMIN() antlr.TerminalNode + USERADMIN() antlr.TerminalNode + SYSADMIN() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + + // IsSystem_defined_roleContext differentiates from other interfaces. + IsSystem_defined_roleContext() +} + +type System_defined_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_defined_roleContext() *System_defined_roleContext { + var p = new(System_defined_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_system_defined_role + return p +} + +func InitEmptySystem_defined_roleContext(p *System_defined_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_system_defined_role +} + +func (*System_defined_roleContext) IsSystem_defined_roleContext() {} + +func NewSystem_defined_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_defined_roleContext { + var p = new(System_defined_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_system_defined_role + + return p +} + +func (s *System_defined_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_defined_roleContext) ORGADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORGADMIN, 0) +} + +func (s *System_defined_roleContext) ACCOUNTADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTADMIN, 0) +} + +func (s *System_defined_roleContext) SECURITYADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITYADMIN, 0) +} + +func (s *System_defined_roleContext) USERADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSERADMIN, 0) +} + +func (s *System_defined_roleContext) SYSADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYSADMIN, 0) +} + +func (s *System_defined_roleContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPUBLIC, 0) +} + +func (s *System_defined_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_defined_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_defined_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSystem_defined_role(s) + } +} + +func (s *System_defined_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSystem_defined_role(s) + } +} + +func (s *System_defined_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSystem_defined_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) System_defined_role() (localctx ISystem_defined_roleContext) { + localctx = NewSystem_defined_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, SnowflakeParserRULE_system_defined_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1913) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserACCOUNTADMIN || _la == SnowflakeParserORGADMIN || _la == SnowflakeParserPUBLIC || _la == SnowflakeParserSECURITYADMIN || _la == SnowflakeParserSYSADMIN || _la == SnowflakeParserUSERADMIN) { + 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 +} + +// IListContext is an interface to support dynamic dispatch. +type IListContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIST() antlr.TerminalNode + Internal_stage() IInternal_stageContext + External_stage() IExternal_stageContext + Pattern() IPatternContext + + // IsListContext differentiates from other interfaces. + IsListContext() +} + +type ListContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyListContext() *ListContext { + var p = new(ListContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_list + return p +} + +func InitEmptyListContext(p *ListContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_list +} + +func (*ListContext) IsListContext() {} + +func NewListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ListContext { + var p = new(ListContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_list + + return p +} + +func (s *ListContext) GetParser() antlr.Parser { return s.parser } + +func (s *ListContext) LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIST, 0) +} + +func (s *ListContext) Internal_stage() IInternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInternal_stageContext) +} + +func (s *ListContext) External_stage() IExternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_stageContext) +} + +func (s *ListContext) Pattern() IPatternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPatternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPatternContext) +} + +func (s *ListContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ListContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterList(s) + } +} + +func (s *ListContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitList(s) + } +} + +func (s *ListContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitList(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) List() (localctx IListContext) { + localctx = NewListContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, SnowflakeParserRULE_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1915) + p.Match(SnowflakeParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 115, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1916) + p.Internal_stage() + } + + case 2: + { + p.SetState(1917) + p.External_stage() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(1921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPATTERN { + { + p.SetState(1920) + p.Pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInternal_stageContext is an interface to support dynamic dispatch. +type IInternal_stageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AT() antlr.TerminalNode + Id_() IId_Context + DIVIDE() antlr.TerminalNode + + // IsInternal_stageContext differentiates from other interfaces. + IsInternal_stageContext() +} + +type Internal_stageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInternal_stageContext() *Internal_stageContext { + var p = new(Internal_stageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_internal_stage + return p +} + +func InitEmptyInternal_stageContext(p *Internal_stageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_internal_stage +} + +func (*Internal_stageContext) IsInternal_stageContext() {} + +func NewInternal_stageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Internal_stageContext { + var p = new(Internal_stageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_internal_stage + + return p +} + +func (s *Internal_stageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Internal_stageContext) AT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAT, 0) +} + +func (s *Internal_stageContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Internal_stageContext) DIVIDE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDIVIDE, 0) +} + +func (s *Internal_stageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Internal_stageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Internal_stageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterInternal_stage(s) + } +} + +func (s *Internal_stageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitInternal_stage(s) + } +} + +func (s *Internal_stageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitInternal_stage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Internal_stage() (localctx IInternal_stageContext) { + localctx = NewInternal_stageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, SnowflakeParserRULE_internal_stage) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1923) + p.Match(SnowflakeParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1924) + p.Id_() + } + { + p.SetState(1925) + p.Match(SnowflakeParserDIVIDE) + 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 +} + +// IExternal_stageContext is an interface to support dynamic dispatch. +type IExternal_stageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AT() antlr.TerminalNode + Id_() IId_Context + DIVIDE() antlr.TerminalNode + + // IsExternal_stageContext differentiates from other interfaces. + IsExternal_stageContext() +} + +type External_stageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_stageContext() *External_stageContext { + var p = new(External_stageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_stage + return p +} + +func InitEmptyExternal_stageContext(p *External_stageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_stage +} + +func (*External_stageContext) IsExternal_stageContext() {} + +func NewExternal_stageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_stageContext { + var p = new(External_stageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_external_stage + + return p +} + +func (s *External_stageContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_stageContext) AT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAT, 0) +} + +func (s *External_stageContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *External_stageContext) DIVIDE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDIVIDE, 0) +} + +func (s *External_stageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_stageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_stageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExternal_stage(s) + } +} + +func (s *External_stageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExternal_stage(s) + } +} + +func (s *External_stageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExternal_stage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) External_stage() (localctx IExternal_stageContext) { + localctx = NewExternal_stageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, SnowflakeParserRULE_external_stage) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1927) + p.Match(SnowflakeParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1928) + p.Id_() + } + { + p.SetState(1929) + p.Match(SnowflakeParserDIVIDE) + 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 +} + +// IPutContext is an interface to support dynamic dispatch. +type IPutContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PUT() antlr.TerminalNode + FILE_PATH() antlr.TerminalNode + Internal_stage() IInternal_stageContext + PARALLEL() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + Num() INumContext + AUTO_COMPRESS() antlr.TerminalNode + AllTrue_false() []ITrue_falseContext + True_false(i int) ITrue_falseContext + SOURCE_COMPRESSION() antlr.TerminalNode + OVERWRITE() antlr.TerminalNode + AUTO_DETECT() antlr.TerminalNode + GZIP() antlr.TerminalNode + BZ2() antlr.TerminalNode + BROTLI() antlr.TerminalNode + ZSTD() antlr.TerminalNode + DEFLATE() antlr.TerminalNode + RAW_DEFLATE() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsPutContext differentiates from other interfaces. + IsPutContext() +} + +type PutContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPutContext() *PutContext { + var p = new(PutContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_put + return p +} + +func InitEmptyPutContext(p *PutContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_put +} + +func (*PutContext) IsPutContext() {} + +func NewPutContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PutContext { + var p = new(PutContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_put + + return p +} + +func (s *PutContext) GetParser() antlr.Parser { return s.parser } + +func (s *PutContext) PUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPUT, 0) +} + +func (s *PutContext) FILE_PATH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE_PATH, 0) +} + +func (s *PutContext) Internal_stage() IInternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInternal_stageContext) +} + +func (s *PutContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARALLEL, 0) +} + +func (s *PutContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *PutContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *PutContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *PutContext) AUTO_COMPRESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_COMPRESS, 0) +} + +func (s *PutContext) AllTrue_false() []ITrue_falseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrue_falseContext); ok { + len++ + } + } + + tst := make([]ITrue_falseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrue_falseContext); ok { + tst[i] = t.(ITrue_falseContext) + i++ + } + } + + return tst +} + +func (s *PutContext) True_false(i int) ITrue_falseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *PutContext) SOURCE_COMPRESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSOURCE_COMPRESSION, 0) +} + +func (s *PutContext) OVERWRITE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOVERWRITE, 0) +} + +func (s *PutContext) AUTO_DETECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_DETECT, 0) +} + +func (s *PutContext) GZIP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGZIP, 0) +} + +func (s *PutContext) BZ2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBZ2, 0) +} + +func (s *PutContext) BROTLI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBROTLI, 0) +} + +func (s *PutContext) ZSTD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserZSTD, 0) +} + +func (s *PutContext) DEFLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFLATE, 0) +} + +func (s *PutContext) RAW_DEFLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRAW_DEFLATE, 0) +} + +func (s *PutContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *PutContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PutContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PutContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPut(s) + } +} + +func (s *PutContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPut(s) + } +} + +func (s *PutContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPut(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Put() (localctx IPutContext) { + localctx = NewPutContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, SnowflakeParserRULE_put) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1931) + p.Match(SnowflakeParserPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1932) + p.Match(SnowflakeParserFILE_PATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1933) + p.Internal_stage() + } + p.SetState(1937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPARALLEL { + { + p.SetState(1934) + p.Match(SnowflakeParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1935) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1936) + p.Num() + } + + } + p.SetState(1942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAUTO_COMPRESS { + { + p.SetState(1939) + p.Match(SnowflakeParserAUTO_COMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1940) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1941) + p.True_false() + } + + } + p.SetState(1947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSOURCE_COMPRESSION { + { + p.SetState(1944) + p.Match(SnowflakeParserSOURCE_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1945) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1946) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-68)) & ^0x3f) == 0 && ((int64(1)<<(_la-68))&9895604649985) != 0) || _la == SnowflakeParserDEFLATE || _la == SnowflakeParserGZIP || _la == SnowflakeParserNONE || _la == SnowflakeParserRAW_DEFLATE || _la == SnowflakeParserZSTD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(1952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOVERWRITE { + { + p.SetState(1949) + p.Match(SnowflakeParserOVERWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1950) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1951) + p.True_false() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRemoveContext is an interface to support dynamic dispatch. +type IRemoveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REMOVE() antlr.TerminalNode + Internal_stage() IInternal_stageContext + External_stage() IExternal_stageContext + Pattern() IPatternContext + + // IsRemoveContext differentiates from other interfaces. + IsRemoveContext() +} + +type RemoveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRemoveContext() *RemoveContext { + var p = new(RemoveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_remove + return p +} + +func InitEmptyRemoveContext(p *RemoveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_remove +} + +func (*RemoveContext) IsRemoveContext() {} + +func NewRemoveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RemoveContext { + var p = new(RemoveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_remove + + return p +} + +func (s *RemoveContext) GetParser() antlr.Parser { return s.parser } + +func (s *RemoveContext) REMOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOVE, 0) +} + +func (s *RemoveContext) Internal_stage() IInternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInternal_stageContext) +} + +func (s *RemoveContext) External_stage() IExternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_stageContext) +} + +func (s *RemoveContext) Pattern() IPatternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPatternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPatternContext) +} + +func (s *RemoveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RemoveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RemoveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRemove(s) + } +} + +func (s *RemoveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRemove(s) + } +} + +func (s *RemoveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRemove(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Remove() (localctx IRemoveContext) { + localctx = NewRemoveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, SnowflakeParserRULE_remove) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1954) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 121, p.GetParserRuleContext()) { + case 1: + { + p.SetState(1955) + p.Internal_stage() + } + + case 2: + { + p.SetState(1956) + p.External_stage() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(1960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPATTERN { + { + p.SetState(1959) + p.Pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_from_roleContext is an interface to support dynamic dispatch. +type IRevoke_from_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + FROM() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ON() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + Object_name() IObject_nameContext + FUTURE() antlr.TerminalNode + Object_type_plural() IObject_type_pluralContext + IN() antlr.TerminalNode + GRANT() antlr.TerminalNode + OPTION() antlr.TerminalNode + FOR() antlr.TerminalNode + ROLE() antlr.TerminalNode + Cascade_restrict() ICascade_restrictContext + Global_privilege() IGlobal_privilegeContext + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + Account_object_privileges() IAccount_object_privilegesContext + RESOURCE() antlr.TerminalNode + MONITOR() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Schema_privileges() ISchema_privilegesContext + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + SCHEMAS() antlr.TerminalNode + Schema_object_privileges() ISchema_object_privilegesContext + Object_type() IObject_typeContext + PRIVILEGES() antlr.TerminalNode + + // IsRevoke_from_roleContext differentiates from other interfaces. + IsRevoke_from_roleContext() +} + +type Revoke_from_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_from_roleContext() *Revoke_from_roleContext { + var p = new(Revoke_from_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_revoke_from_role + return p +} + +func InitEmptyRevoke_from_roleContext(p *Revoke_from_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_revoke_from_role +} + +func (*Revoke_from_roleContext) IsRevoke_from_roleContext() {} + +func NewRevoke_from_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_from_roleContext { + var p = new(Revoke_from_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_revoke_from_role + + return p +} + +func (s *Revoke_from_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_from_roleContext) REVOKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREVOKE, 0) +} + +func (s *Revoke_from_roleContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Revoke_from_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Revoke_from_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Revoke_from_roleContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Revoke_from_roleContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Revoke_from_roleContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Revoke_from_roleContext) FUTURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUTURE, 0) +} + +func (s *Revoke_from_roleContext) Object_type_plural() IObject_type_pluralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_pluralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_pluralContext) +} + +func (s *Revoke_from_roleContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Revoke_from_roleContext) GRANT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANT, 0) +} + +func (s *Revoke_from_roleContext) OPTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPTION, 0) +} + +func (s *Revoke_from_roleContext) FOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFOR, 0) +} + +func (s *Revoke_from_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Revoke_from_roleContext) Cascade_restrict() ICascade_restrictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICascade_restrictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICascade_restrictContext) +} + +func (s *Revoke_from_roleContext) Global_privilege() IGlobal_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGlobal_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGlobal_privilegeContext) +} + +func (s *Revoke_from_roleContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserALL) +} + +func (s *Revoke_from_roleContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, i) +} + +func (s *Revoke_from_roleContext) Account_object_privileges() IAccount_object_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccount_object_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccount_object_privilegesContext) +} + +func (s *Revoke_from_roleContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE, 0) +} + +func (s *Revoke_from_roleContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Revoke_from_roleContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Revoke_from_roleContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Revoke_from_roleContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Revoke_from_roleContext) Schema_privileges() ISchema_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_privilegesContext) +} + +func (s *Revoke_from_roleContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Revoke_from_roleContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Revoke_from_roleContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMAS, 0) +} + +func (s *Revoke_from_roleContext) Schema_object_privileges() ISchema_object_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_privilegesContext) +} + +func (s *Revoke_from_roleContext) Object_type() IObject_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_typeContext) +} + +func (s *Revoke_from_roleContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIVILEGES, 0) +} + +func (s *Revoke_from_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_from_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_from_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRevoke_from_role(s) + } +} + +func (s *Revoke_from_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRevoke_from_role(s) + } +} + +func (s *Revoke_from_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRevoke_from_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Revoke_from_role() (localctx IRevoke_from_roleContext) { + localctx = NewRevoke_from_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, SnowflakeParserRULE_revoke_from_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(1962) + p.Match(SnowflakeParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserGRANT { + { + p.SetState(1963) + p.Match(SnowflakeParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1964) + p.Match(SnowflakeParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1965) + p.Match(SnowflakeParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 140, p.GetParserRuleContext()) { + case 1: + p.SetState(1973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAPPLY, SnowflakeParserATTACH, SnowflakeParserCREATE, SnowflakeParserEXECUTE, SnowflakeParserIMPORT, SnowflakeParserMANAGE, SnowflakeParserMONITOR, SnowflakeParserOVERRIDE: + { + p.SetState(1968) + p.Global_privilege() + } + + case SnowflakeParserALL: + { + p.SetState(1969) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1970) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1975) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1976) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(1982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCREATE, SnowflakeParserIMPORTED, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserOPERATE, SnowflakeParserUSAGE, SnowflakeParserUSE_ANY_ROLE: + { + p.SetState(1977) + p.Account_object_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(1978) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1979) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1984) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserRESOURCE: + { + p.SetState(1985) + p.Match(SnowflakeParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(1986) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserWAREHOUSE: + { + p.SetState(1987) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(1988) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserINTEGRATION: + { + p.SetState(1989) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(1992) + p.Object_name() + } + + case 3: + p.SetState(1998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD, SnowflakeParserCREATE, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserUSAGE: + { + p.SetState(1993) + p.Schema_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(1994) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(1996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(1995) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2000) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSCHEMA: + { + p.SetState(2001) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2002) + p.Schema_name() + } + + case SnowflakeParserALL: + { + p.SetState(2003) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2004) + p.Match(SnowflakeParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2005) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2006) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2007) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + p.SetState(2015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD, SnowflakeParserCREATE, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserUSAGE: + { + p.SetState(2010) + p.Schema_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(2011) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2013) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(2012) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2017) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(2018) + p.Match(SnowflakeParserFUTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2019) + p.Match(SnowflakeParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2020) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2021) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.SetState(2027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAPPLY, SnowflakeParserDELETE, SnowflakeParserINSERT, SnowflakeParserMONITOR, SnowflakeParserOPERATE, SnowflakeParserREAD, SnowflakeParserREFERENCES, SnowflakeParserSELECT, SnowflakeParserTRUNCATE, SnowflakeParserUPDATE, SnowflakeParserUSAGE: + { + p.SetState(2022) + p.Schema_object_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(2023) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(2024) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2029) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT, SnowflakeParserDATABASES, SnowflakeParserINTEGRATIONS, SnowflakeParserNETWORK, SnowflakeParserRESOURCE, SnowflakeParserROLES, SnowflakeParserSHARES, SnowflakeParserUSERS, SnowflakeParserWAREHOUSES: + { + p.SetState(2030) + p.Object_type() + } + { + p.SetState(2031) + p.Object_name() + } + + case SnowflakeParserALL: + { + p.SetState(2033) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2034) + p.Object_type_plural() + } + { + p.SetState(2035) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2036) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2037) + p.Schema_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 6: + p.SetState(2046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAPPLY, SnowflakeParserDELETE, SnowflakeParserINSERT, SnowflakeParserMONITOR, SnowflakeParserOPERATE, SnowflakeParserREAD, SnowflakeParserREFERENCES, SnowflakeParserSELECT, SnowflakeParserTRUNCATE, SnowflakeParserUPDATE, SnowflakeParserUSAGE: + { + p.SetState(2041) + p.Schema_object_privileges() + } + + case SnowflakeParserALL: + { + p.SetState(2042) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2044) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRIVILEGES { + { + p.SetState(2043) + p.Match(SnowflakeParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(2048) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2049) + p.Match(SnowflakeParserFUTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2050) + p.Object_type_plural() + } + { + p.SetState(2051) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATABASE: + { + p.SetState(2052) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2053) + p.Id_() + } + + case SnowflakeParserSCHEMA: + { + p.SetState(2054) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2055) + p.Schema_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(2060) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2062) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 141, p.GetParserRuleContext()) == 1 { + { + p.SetState(2061) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2064) + p.Id_() + } + p.SetState(2066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT { + { + p.SetState(2065) + p.Cascade_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 +} + +// IRevoke_from_shareContext is an interface to support dynamic dispatch. +type IRevoke_from_shareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Object_privilege() IObject_privilegeContext + ON() antlr.TerminalNode + FROM() antlr.TerminalNode + SHARE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + ALL() antlr.TerminalNode + TABLES() antlr.TerminalNode + IN() antlr.TerminalNode + VIEW() antlr.TerminalNode + VIEWS() antlr.TerminalNode + + // IsRevoke_from_shareContext differentiates from other interfaces. + IsRevoke_from_shareContext() +} + +type Revoke_from_shareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_from_shareContext() *Revoke_from_shareContext { + var p = new(Revoke_from_shareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_revoke_from_share + return p +} + +func InitEmptyRevoke_from_shareContext(p *Revoke_from_shareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_revoke_from_share +} + +func (*Revoke_from_shareContext) IsRevoke_from_shareContext() {} + +func NewRevoke_from_shareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_from_shareContext { + var p = new(Revoke_from_shareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_revoke_from_share + + return p +} + +func (s *Revoke_from_shareContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_from_shareContext) REVOKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREVOKE, 0) +} + +func (s *Revoke_from_shareContext) Object_privilege() IObject_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_privilegeContext) +} + +func (s *Revoke_from_shareContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Revoke_from_shareContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Revoke_from_shareContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Revoke_from_shareContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Revoke_from_shareContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Revoke_from_shareContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Revoke_from_shareContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Revoke_from_shareContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Revoke_from_shareContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Revoke_from_shareContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Revoke_from_shareContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Revoke_from_shareContext) TABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLES, 0) +} + +func (s *Revoke_from_shareContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Revoke_from_shareContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Revoke_from_shareContext) VIEWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEWS, 0) +} + +func (s *Revoke_from_shareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_from_shareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_from_shareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRevoke_from_share(s) + } +} + +func (s *Revoke_from_shareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRevoke_from_share(s) + } +} + +func (s *Revoke_from_shareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRevoke_from_share(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Revoke_from_share() (localctx IRevoke_from_shareContext) { + localctx = NewRevoke_from_shareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, SnowflakeParserRULE_revoke_from_share) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2068) + p.Match(SnowflakeParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2069) + p.Object_privilege() + } + { + p.SetState(2070) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 145, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2071) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2072) + p.Id_() + } + + case 2: + { + p.SetState(2073) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2074) + p.Schema_name() + } + + case 3: + p.SetState(2082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserTABLE: + { + p.SetState(2075) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2076) + p.Object_name() + } + + case SnowflakeParserALL: + { + p.SetState(2077) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2078) + p.Match(SnowflakeParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2079) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2080) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2081) + p.Schema_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + p.SetState(2091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserVIEW: + { + p.SetState(2084) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2085) + p.Object_name() + } + + case SnowflakeParserALL: + { + p.SetState(2086) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2087) + p.Match(SnowflakeParserVIEWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2088) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2089) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2090) + p.Schema_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(2095) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2096) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2097) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRevoke_roleContext is an interface to support dynamic dispatch. +type IRevoke_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + AllROLE() []antlr.TerminalNode + ROLE(i int) antlr.TerminalNode + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + FROM() antlr.TerminalNode + USER() antlr.TerminalNode + Id_() IId_Context + + // IsRevoke_roleContext differentiates from other interfaces. + IsRevoke_roleContext() +} + +type Revoke_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_roleContext() *Revoke_roleContext { + var p = new(Revoke_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_revoke_role + return p +} + +func InitEmptyRevoke_roleContext(p *Revoke_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_revoke_role +} + +func (*Revoke_roleContext) IsRevoke_roleContext() {} + +func NewRevoke_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_roleContext { + var p = new(Revoke_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_revoke_role + + return p +} + +func (s *Revoke_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_roleContext) REVOKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREVOKE, 0) +} + +func (s *Revoke_roleContext) AllROLE() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserROLE) +} + +func (s *Revoke_roleContext) ROLE(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, i) +} + +func (s *Revoke_roleContext) AllRole_name() []IRole_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_nameContext); ok { + len++ + } + } + + tst := make([]IRole_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_nameContext); ok { + tst[i] = t.(IRole_nameContext) + i++ + } + } + + return tst +} + +func (s *Revoke_roleContext) Role_name(i int) IRole_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Revoke_roleContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Revoke_roleContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Revoke_roleContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Revoke_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRevoke_role(s) + } +} + +func (s *Revoke_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRevoke_role(s) + } +} + +func (s *Revoke_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRevoke_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Revoke_role() (localctx IRevoke_roleContext) { + localctx = NewRevoke_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, SnowflakeParserRULE_revoke_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2099) + p.Match(SnowflakeParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2100) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2101) + p.Role_name() + } + { + p.SetState(2102) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserROLE: + { + p.SetState(2103) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2104) + p.Role_name() + } + + case SnowflakeParserUSER: + { + p.SetState(2105) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2106) + p.Id_() + } + + 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 +} + +// IRollbackContext is an interface to support dynamic dispatch. +type IRollbackContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLBACK() antlr.TerminalNode + WORK() antlr.TerminalNode + + // IsRollbackContext differentiates from other interfaces. + IsRollbackContext() +} + +type RollbackContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollbackContext() *RollbackContext { + var p = new(RollbackContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_rollback + return p +} + +func InitEmptyRollbackContext(p *RollbackContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_rollback +} + +func (*RollbackContext) IsRollbackContext() {} + +func NewRollbackContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RollbackContext { + var p = new(RollbackContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_rollback + + return p +} + +func (s *RollbackContext) GetParser() antlr.Parser { return s.parser } + +func (s *RollbackContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLLBACK, 0) +} + +func (s *RollbackContext) WORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWORK, 0) +} + +func (s *RollbackContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *RollbackContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *RollbackContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRollback(s) + } +} + +func (s *RollbackContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRollback(s) + } +} + +func (s *RollbackContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRollback(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Rollback() (localctx IRollbackContext) { + localctx = NewRollbackContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, SnowflakeParserRULE_rollback) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2109) + p.Match(SnowflakeParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWORK { + { + p.SetState(2110) + p.Match(SnowflakeParserWORK) + 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 +} + +// ISetContext is an interface to support dynamic dispatch. +type ISetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + EQ() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSetContext differentiates from other interfaces. + IsSetContext() +} + +type SetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySetContext() *SetContext { + var p = new(SetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_set + return p +} + +func InitEmptySetContext(p *SetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_set +} + +func (*SetContext) IsSetContext() {} + +func NewSetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SetContext { + var p = new(SetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_set + + return p +} + +func (s *SetContext) GetParser() antlr.Parser { return s.parser } + +func (s *SetContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *SetContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *SetContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *SetContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *SetContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *SetContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *SetContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *SetContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *SetContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *SetContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *SetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *SetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *SetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSet(s) + } +} + +func (s *SetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSet(s) + } +} + +func (s *SetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSet(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Set() (localctx ISetContext) { + localctx = NewSetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, SnowflakeParserRULE_set) + var _la int + + p.SetState(2141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 150, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2113) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2114) + p.Id_() + } + { + p.SetState(2115) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2116) + p.expr(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2118) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2119) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2120) + p.Id_() + } + p.SetState(2125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2121) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2122) + p.Id_() + } + + p.SetState(2127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2128) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2129) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2130) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2131) + p.expr(0) + } + p.SetState(2136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2132) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2133) + p.expr(0) + } + + p.SetState(2138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2139) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// ITruncate_materialized_viewContext is an interface to support dynamic dispatch. +type ITruncate_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsTruncate_materialized_viewContext differentiates from other interfaces. + IsTruncate_materialized_viewContext() +} + +type Truncate_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_materialized_viewContext() *Truncate_materialized_viewContext { + var p = new(Truncate_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_truncate_materialized_view + return p +} + +func InitEmptyTruncate_materialized_viewContext(p *Truncate_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_truncate_materialized_view +} + +func (*Truncate_materialized_viewContext) IsTruncate_materialized_viewContext() {} + +func NewTruncate_materialized_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_materialized_viewContext { + var p = new(Truncate_materialized_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_truncate_materialized_view + + return p +} + +func (s *Truncate_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_materialized_viewContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUNCATE, 0) +} + +func (s *Truncate_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATERIALIZED, 0) +} + +func (s *Truncate_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Truncate_materialized_viewContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Truncate_materialized_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_materialized_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_materialized_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTruncate_materialized_view(s) + } +} + +func (s *Truncate_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTruncate_materialized_view(s) + } +} + +func (s *Truncate_materialized_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTruncate_materialized_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Truncate_materialized_view() (localctx ITruncate_materialized_viewContext) { + localctx = NewTruncate_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, SnowflakeParserRULE_truncate_materialized_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2143) + p.Match(SnowflakeParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2144) + p.Match(SnowflakeParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2145) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2146) + p.Object_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 +} + +// ITruncate_tableContext is an interface to support dynamic dispatch. +type ITruncate_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + Object_name() IObject_nameContext + TABLE() antlr.TerminalNode + If_exists() IIf_existsContext + + // IsTruncate_tableContext differentiates from other interfaces. + IsTruncate_tableContext() +} + +type Truncate_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_tableContext() *Truncate_tableContext { + var p = new(Truncate_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_truncate_table + return p +} + +func InitEmptyTruncate_tableContext(p *Truncate_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_truncate_table +} + +func (*Truncate_tableContext) IsTruncate_tableContext() {} + +func NewTruncate_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_tableContext { + var p = new(Truncate_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_truncate_table + + return p +} + +func (s *Truncate_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_tableContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUNCATE, 0) +} + +func (s *Truncate_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Truncate_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Truncate_tableContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Truncate_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTruncate_table(s) + } +} + +func (s *Truncate_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTruncate_table(s) + } +} + +func (s *Truncate_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTruncate_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Truncate_table() (localctx ITruncate_tableContext) { + localctx = NewTruncate_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, SnowflakeParserRULE_truncate_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2148) + p.Match(SnowflakeParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTABLE { + { + p.SetState(2149) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2153) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 152, p.GetParserRuleContext()) == 1 { + { + p.SetState(2152) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2155) + p.Object_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 +} + +// IUnsetContext is an interface to support dynamic dispatch. +type IUnsetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUnsetContext differentiates from other interfaces. + IsUnsetContext() +} + +type UnsetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnsetContext() *UnsetContext { + var p = new(UnsetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_unset + return p +} + +func InitEmptyUnsetContext(p *UnsetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_unset +} + +func (*UnsetContext) IsUnsetContext() {} + +func NewUnsetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnsetContext { + var p = new(UnsetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_unset + + return p +} + +func (s *UnsetContext) GetParser() antlr.Parser { return s.parser } + +func (s *UnsetContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *UnsetContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *UnsetContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *UnsetContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *UnsetContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *UnsetContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *UnsetContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *UnsetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *UnsetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *UnsetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUnset(s) + } +} + +func (s *UnsetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUnset(s) + } +} + +func (s *UnsetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUnset(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Unset() (localctx IUnsetContext) { + localctx = NewUnsetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, SnowflakeParserRULE_unset) + var _la int + + p.SetState(2171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 154, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2157) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2158) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2159) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2160) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2161) + p.Id_() + } + p.SetState(2166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2162) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2163) + p.Id_() + } + + p.SetState(2168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2169) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// IAlter_commandContext is an interface to support dynamic dispatch. +type IAlter_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_account() IAlter_accountContext + Alter_alert() IAlter_alertContext + Alter_api_integration() IAlter_api_integrationContext + Alter_connection() IAlter_connectionContext + Alter_database() IAlter_databaseContext + Alter_dynamic_table() IAlter_dynamic_tableContext + Alter_external_table() IAlter_external_tableContext + Alter_failover_group() IAlter_failover_groupContext + Alter_file_format() IAlter_file_formatContext + Alter_function() IAlter_functionContext + Alter_masking_policy() IAlter_masking_policyContext + Alter_materialized_view() IAlter_materialized_viewContext + Alter_network_policy() IAlter_network_policyContext + Alter_notification_integration() IAlter_notification_integrationContext + Alter_pipe() IAlter_pipeContext + Alter_procedure() IAlter_procedureContext + Alter_replication_group() IAlter_replication_groupContext + Alter_resource_monitor() IAlter_resource_monitorContext + Alter_role() IAlter_roleContext + Alter_row_access_policy() IAlter_row_access_policyContext + Alter_schema() IAlter_schemaContext + Alter_security_integration() IAlter_security_integrationContext + Alter_security_integration_external_oauth() IAlter_security_integration_external_oauthContext + Alter_security_integration_snowflake_oauth() IAlter_security_integration_snowflake_oauthContext + Alter_security_integration_saml2() IAlter_security_integration_saml2Context + Alter_security_integration_scim() IAlter_security_integration_scimContext + Alter_sequence() IAlter_sequenceContext + Alter_session() IAlter_sessionContext + Alter_session_policy() IAlter_session_policyContext + Alter_share() IAlter_shareContext + Alter_stage() IAlter_stageContext + Alter_storage_integration() IAlter_storage_integrationContext + Alter_stream() IAlter_streamContext + Alter_table() IAlter_tableContext + Alter_table_alter_column() IAlter_table_alter_columnContext + Alter_tag() IAlter_tagContext + Alter_task() IAlter_taskContext + Alter_user() IAlter_userContext + Alter_view() IAlter_viewContext + Alter_warehouse() IAlter_warehouseContext + + // IsAlter_commandContext differentiates from other interfaces. + IsAlter_commandContext() +} + +type Alter_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_commandContext() *Alter_commandContext { + var p = new(Alter_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_command + return p +} + +func InitEmptyAlter_commandContext(p *Alter_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_command +} + +func (*Alter_commandContext) IsAlter_commandContext() {} + +func NewAlter_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_commandContext { + var p = new(Alter_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_command + + return p +} + +func (s *Alter_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_commandContext) Alter_account() IAlter_accountContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_accountContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_accountContext) +} + +func (s *Alter_commandContext) Alter_alert() IAlter_alertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_alertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_alertContext) +} + +func (s *Alter_commandContext) Alter_api_integration() IAlter_api_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_api_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_api_integrationContext) +} + +func (s *Alter_commandContext) Alter_connection() IAlter_connectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_connectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_connectionContext) +} + +func (s *Alter_commandContext) Alter_database() IAlter_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_databaseContext) +} + +func (s *Alter_commandContext) Alter_dynamic_table() IAlter_dynamic_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_dynamic_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_dynamic_tableContext) +} + +func (s *Alter_commandContext) Alter_external_table() IAlter_external_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_external_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_external_tableContext) +} + +func (s *Alter_commandContext) Alter_failover_group() IAlter_failover_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_failover_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_failover_groupContext) +} + +func (s *Alter_commandContext) Alter_file_format() IAlter_file_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_file_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_file_formatContext) +} + +func (s *Alter_commandContext) Alter_function() IAlter_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_functionContext) +} + +func (s *Alter_commandContext) Alter_masking_policy() IAlter_masking_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_masking_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_masking_policyContext) +} + +func (s *Alter_commandContext) Alter_materialized_view() IAlter_materialized_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_materialized_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_materialized_viewContext) +} + +func (s *Alter_commandContext) Alter_network_policy() IAlter_network_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_network_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_network_policyContext) +} + +func (s *Alter_commandContext) Alter_notification_integration() IAlter_notification_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_notification_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_notification_integrationContext) +} + +func (s *Alter_commandContext) Alter_pipe() IAlter_pipeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_pipeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_pipeContext) +} + +func (s *Alter_commandContext) Alter_procedure() IAlter_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_procedureContext) +} + +func (s *Alter_commandContext) Alter_replication_group() IAlter_replication_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_replication_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_replication_groupContext) +} + +func (s *Alter_commandContext) Alter_resource_monitor() IAlter_resource_monitorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_resource_monitorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_resource_monitorContext) +} + +func (s *Alter_commandContext) Alter_role() IAlter_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_roleContext) +} + +func (s *Alter_commandContext) Alter_row_access_policy() IAlter_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_row_access_policyContext) +} + +func (s *Alter_commandContext) Alter_schema() IAlter_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_schemaContext) +} + +func (s *Alter_commandContext) Alter_security_integration() IAlter_security_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_security_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_security_integrationContext) +} + +func (s *Alter_commandContext) Alter_security_integration_external_oauth() IAlter_security_integration_external_oauthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_security_integration_external_oauthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_security_integration_external_oauthContext) +} + +func (s *Alter_commandContext) Alter_security_integration_snowflake_oauth() IAlter_security_integration_snowflake_oauthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_security_integration_snowflake_oauthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_security_integration_snowflake_oauthContext) +} + +func (s *Alter_commandContext) Alter_security_integration_saml2() IAlter_security_integration_saml2Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_security_integration_saml2Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_security_integration_saml2Context) +} + +func (s *Alter_commandContext) Alter_security_integration_scim() IAlter_security_integration_scimContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_security_integration_scimContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_security_integration_scimContext) +} + +func (s *Alter_commandContext) Alter_sequence() IAlter_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_sequenceContext) +} + +func (s *Alter_commandContext) Alter_session() IAlter_sessionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_sessionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_sessionContext) +} + +func (s *Alter_commandContext) Alter_session_policy() IAlter_session_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_session_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_session_policyContext) +} + +func (s *Alter_commandContext) Alter_share() IAlter_shareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_shareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_shareContext) +} + +func (s *Alter_commandContext) Alter_stage() IAlter_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_stageContext) +} + +func (s *Alter_commandContext) Alter_storage_integration() IAlter_storage_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_storage_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_storage_integrationContext) +} + +func (s *Alter_commandContext) Alter_stream() IAlter_streamContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_streamContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_streamContext) +} + +func (s *Alter_commandContext) Alter_table() IAlter_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tableContext) +} + +func (s *Alter_commandContext) Alter_table_alter_column() IAlter_table_alter_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_alter_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_alter_columnContext) +} + +func (s *Alter_commandContext) Alter_tag() IAlter_tagContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tagContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tagContext) +} + +func (s *Alter_commandContext) Alter_task() IAlter_taskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_taskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_taskContext) +} + +func (s *Alter_commandContext) Alter_user() IAlter_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_userContext) +} + +func (s *Alter_commandContext) Alter_view() IAlter_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_viewContext) +} + +func (s *Alter_commandContext) Alter_warehouse() IAlter_warehouseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_warehouseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_warehouseContext) +} + +func (s *Alter_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_command(s) + } +} + +func (s *Alter_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_command(s) + } +} + +func (s *Alter_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_command() (localctx IAlter_commandContext) { + localctx = NewAlter_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, SnowflakeParserRULE_alter_command) + p.SetState(2213) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 155, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2173) + p.Alter_account() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2174) + p.Alter_alert() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2175) + p.Alter_api_integration() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2176) + p.Alter_connection() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2177) + p.Alter_database() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2178) + p.Alter_dynamic_table() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2179) + p.Alter_external_table() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2180) + p.Alter_failover_group() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2181) + p.Alter_file_format() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2182) + p.Alter_function() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2183) + p.Alter_masking_policy() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2184) + p.Alter_materialized_view() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2185) + p.Alter_network_policy() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2186) + p.Alter_notification_integration() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2187) + p.Alter_pipe() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2188) + p.Alter_procedure() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2189) + p.Alter_replication_group() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2190) + p.Alter_resource_monitor() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2191) + p.Alter_role() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2192) + p.Alter_row_access_policy() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2193) + p.Alter_schema() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2194) + p.Alter_security_integration() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2195) + p.Alter_security_integration_external_oauth() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2196) + p.Alter_security_integration_snowflake_oauth() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2197) + p.Alter_security_integration_saml2() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2198) + p.Alter_security_integration_scim() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2199) + p.Alter_sequence() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(2200) + p.Alter_session() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(2201) + p.Alter_session_policy() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(2202) + p.Alter_share() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(2203) + p.Alter_stage() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(2204) + p.Alter_storage_integration() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(2205) + p.Alter_stream() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(2206) + p.Alter_table() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(2207) + p.Alter_table_alter_column() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(2208) + p.Alter_tag() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(2209) + p.Alter_task() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(2210) + p.Alter_user() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(2211) + p.Alter_view() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(2212) + p.Alter_warehouse() + } + + 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 +} + +// IAccount_paramsContext is an interface to support dynamic dispatch. +type IAccount_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALLOW_ID_TOKEN() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + CLIENT_ENCRYPTION_KEY_SIZE() antlr.TerminalNode + Num() INumContext + ENFORCE_SESSION_POLICY() antlr.TerminalNode + EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST() antlr.TerminalNode + INITIAL_REPLICATION_SIZE_LIMIT_IN_TB() antlr.TerminalNode + NETWORK_POLICY() antlr.TerminalNode + String_() IStringContext + PERIODIC_DATA_REKEYING() antlr.TerminalNode + PREVENT_UNLOAD_TO_INLINE_URL() antlr.TerminalNode + PREVENT_UNLOAD_TO_INTERNAL_STAGES() antlr.TerminalNode + REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION() antlr.TerminalNode + REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION() antlr.TerminalNode + SAML_IDENTITY_PROVIDER() antlr.TerminalNode + Json_literal() IJson_literalContext + SESSION_POLICY() antlr.TerminalNode + SSO_LOGIN_PAGE() antlr.TerminalNode + + // IsAccount_paramsContext differentiates from other interfaces. + IsAccount_paramsContext() +} + +type Account_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccount_paramsContext() *Account_paramsContext { + var p = new(Account_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_params + return p +} + +func InitEmptyAccount_paramsContext(p *Account_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_params +} + +func (*Account_paramsContext) IsAccount_paramsContext() {} + +func NewAccount_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Account_paramsContext { + var p = new(Account_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_account_params + + return p +} + +func (s *Account_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Account_paramsContext) ALLOW_ID_TOKEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_ID_TOKEN, 0) +} + +func (s *Account_paramsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Account_paramsContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Account_paramsContext) CLIENT_ENCRYPTION_KEY_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, 0) +} + +func (s *Account_paramsContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Account_paramsContext) ENFORCE_SESSION_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENFORCE_SESSION_POLICY, 0) +} + +func (s *Account_paramsContext) EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, 0) +} + +func (s *Account_paramsContext) INITIAL_REPLICATION_SIZE_LIMIT_IN_TB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, 0) +} + +func (s *Account_paramsContext) NETWORK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK_POLICY, 0) +} + +func (s *Account_paramsContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Account_paramsContext) PERIODIC_DATA_REKEYING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERIODIC_DATA_REKEYING, 0) +} + +func (s *Account_paramsContext) PREVENT_UNLOAD_TO_INLINE_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, 0) +} + +func (s *Account_paramsContext) PREVENT_UNLOAD_TO_INTERNAL_STAGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, 0) +} + +func (s *Account_paramsContext) REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, 0) +} + +func (s *Account_paramsContext) REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, 0) +} + +func (s *Account_paramsContext) SAML_IDENTITY_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML_IDENTITY_PROVIDER, 0) +} + +func (s *Account_paramsContext) Json_literal() IJson_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_literalContext) +} + +func (s *Account_paramsContext) SESSION_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_POLICY, 0) +} + +func (s *Account_paramsContext) SSO_LOGIN_PAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSSO_LOGIN_PAGE, 0) +} + +func (s *Account_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Account_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Account_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAccount_params(s) + } +} + +func (s *Account_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAccount_params(s) + } +} + +func (s *Account_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAccount_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Account_params() (localctx IAccount_paramsContext) { + localctx = NewAccount_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, SnowflakeParserRULE_account_params) + p.SetState(2257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserALLOW_ID_TOKEN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2215) + p.Match(SnowflakeParserALLOW_ID_TOKEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2216) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2217) + p.True_false() + } + + case SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2218) + p.Match(SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2219) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2220) + p.Num() + } + + case SnowflakeParserENFORCE_SESSION_POLICY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2221) + p.Match(SnowflakeParserENFORCE_SESSION_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2222) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2223) + p.True_false() + } + + case SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2224) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2225) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2226) + p.True_false() + } + + case SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2227) + p.Match(SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2228) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2229) + p.Num() + } + + case SnowflakeParserNETWORK_POLICY: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2230) + p.Match(SnowflakeParserNETWORK_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2231) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2232) + p.String_() + } + + case SnowflakeParserPERIODIC_DATA_REKEYING: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2233) + p.Match(SnowflakeParserPERIODIC_DATA_REKEYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2234) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2235) + p.True_false() + } + + case SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2236) + p.Match(SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2237) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2238) + p.True_false() + } + + case SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2239) + p.Match(SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2240) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2241) + p.True_false() + } + + case SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2242) + p.Match(SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2243) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2244) + p.True_false() + } + + case SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2245) + p.Match(SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2246) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2247) + p.True_false() + } + + case SnowflakeParserSAML_IDENTITY_PROVIDER: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2248) + p.Match(SnowflakeParserSAML_IDENTITY_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2249) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2250) + p.Json_literal() + } + + case SnowflakeParserSESSION_POLICY: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2251) + p.Match(SnowflakeParserSESSION_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2252) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2253) + p.String_() + } + + case SnowflakeParserSSO_LOGIN_PAGE: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2254) + p.Match(SnowflakeParserSSO_LOGIN_PAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2255) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2256) + p.True_false() + } + + 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_paramsContext is an interface to support dynamic dispatch. +type IObject_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + EQ() antlr.TerminalNode + Num() INumContext + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + Default_ddl_collation() IDefault_ddl_collationContext + MAX_CONCURRENCY_LEVEL() antlr.TerminalNode + NETWORK_POLICY() antlr.TerminalNode + String_() IStringContext + PIPE_EXECUTION_PAUSED() antlr.TerminalNode + True_false() ITrue_falseContext + SESSION_POLICY() antlr.TerminalNode + STATEMENT_QUEUED_TIMEOUT_IN_SECONDS() antlr.TerminalNode + STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode + + // IsObject_paramsContext differentiates from other interfaces. + IsObject_paramsContext() +} + +type Object_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_paramsContext() *Object_paramsContext { + var p = new(Object_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_params + return p +} + +func InitEmptyObject_paramsContext(p *Object_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_params +} + +func (*Object_paramsContext) IsObject_paramsContext() {} + +func NewObject_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_paramsContext { + var p = new(Object_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_object_params + + return p +} + +func (s *Object_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_paramsContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Object_paramsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Object_paramsContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Object_paramsContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Object_paramsContext) Default_ddl_collation() IDefault_ddl_collationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_ddl_collationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_ddl_collationContext) +} + +func (s *Object_paramsContext) MAX_CONCURRENCY_LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_CONCURRENCY_LEVEL, 0) +} + +func (s *Object_paramsContext) NETWORK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK_POLICY, 0) +} + +func (s *Object_paramsContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Object_paramsContext) PIPE_EXECUTION_PAUSED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE_EXECUTION_PAUSED, 0) +} + +func (s *Object_paramsContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Object_paramsContext) SESSION_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_POLICY, 0) +} + +func (s *Object_paramsContext) STATEMENT_QUEUED_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Object_paramsContext) STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Object_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterObject_params(s) + } +} + +func (s *Object_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_params(s) + } +} + +func (s *Object_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_params() (localctx IObject_paramsContext) { + localctx = NewObject_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, SnowflakeParserRULE_object_params) + p.SetState(2284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATA_RETENTION_TIME_IN_DAYS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2259) + p.Match(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2260) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2261) + p.Num() + } + + case SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2262) + p.Match(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2263) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2264) + p.Num() + } + + case SnowflakeParserDEFAULT_DDL_COLLATION_: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2265) + p.Default_ddl_collation() + } + + case SnowflakeParserMAX_CONCURRENCY_LEVEL: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2266) + p.Match(SnowflakeParserMAX_CONCURRENCY_LEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2267) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2268) + p.Num() + } + + case SnowflakeParserNETWORK_POLICY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2269) + p.Match(SnowflakeParserNETWORK_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2270) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2271) + p.String_() + } + + case SnowflakeParserPIPE_EXECUTION_PAUSED: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2272) + p.Match(SnowflakeParserPIPE_EXECUTION_PAUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2273) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2274) + p.True_false() + } + + case SnowflakeParserSESSION_POLICY: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2275) + p.Match(SnowflakeParserSESSION_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2276) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2277) + p.String_() + } + + case SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2278) + p.Match(SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2279) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2280) + p.Num() + } + + case SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2281) + p.Match(SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2282) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2283) + p.Num() + } + + 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 +} + +// IDefault_ddl_collationContext is an interface to support dynamic dispatch. +type IDefault_ddl_collationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT_DDL_COLLATION_() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsDefault_ddl_collationContext differentiates from other interfaces. + IsDefault_ddl_collationContext() +} + +type Default_ddl_collationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_ddl_collationContext() *Default_ddl_collationContext { + var p = new(Default_ddl_collationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_default_ddl_collation + return p +} + +func InitEmptyDefault_ddl_collationContext(p *Default_ddl_collationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_default_ddl_collation +} + +func (*Default_ddl_collationContext) IsDefault_ddl_collationContext() {} + +func NewDefault_ddl_collationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_ddl_collationContext { + var p = new(Default_ddl_collationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_default_ddl_collation + + return p +} + +func (s *Default_ddl_collationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_ddl_collationContext) DEFAULT_DDL_COLLATION_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_DDL_COLLATION_, 0) +} + +func (s *Default_ddl_collationContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Default_ddl_collationContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Default_ddl_collationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_ddl_collationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_ddl_collationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDefault_ddl_collation(s) + } +} + +func (s *Default_ddl_collationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDefault_ddl_collation(s) + } +} + +func (s *Default_ddl_collationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDefault_ddl_collation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Default_ddl_collation() (localctx IDefault_ddl_collationContext) { + localctx = NewDefault_ddl_collationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, SnowflakeParserRULE_default_ddl_collation) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2286) + p.Match(SnowflakeParserDEFAULT_DDL_COLLATION_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2287) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2288) + p.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 +} + +// IObject_propertiesContext is an interface to support dynamic dispatch. +type IObject_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PASSWORD() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + LOGIN_NAME() antlr.TerminalNode + DISPLAY_NAME() antlr.TerminalNode + FIRST_NAME() antlr.TerminalNode + MIDDLE_NAME() antlr.TerminalNode + LAST_NAME() antlr.TerminalNode + EMAIL() antlr.TerminalNode + MUST_CHANGE_PASSWORD() antlr.TerminalNode + True_false() ITrue_falseContext + DISABLED() antlr.TerminalNode + DAYS_TO_EXPIRY() antlr.TerminalNode + Num() INumContext + MINS_TO_UNLOCK() antlr.TerminalNode + DEFAULT_WAREHOUSE() antlr.TerminalNode + DEFAULT_NAMESPACE() antlr.TerminalNode + DEFAULT_ROLE() antlr.TerminalNode + MINS_TO_BYPASS_MFA() antlr.TerminalNode + RSA_PUBLIC_KEY() antlr.TerminalNode + RSA_PUBLIC_KEY_2() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsObject_propertiesContext differentiates from other interfaces. + IsObject_propertiesContext() +} + +type Object_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_propertiesContext() *Object_propertiesContext { + var p = new(Object_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_properties + return p +} + +func InitEmptyObject_propertiesContext(p *Object_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_properties +} + +func (*Object_propertiesContext) IsObject_propertiesContext() {} + +func NewObject_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_propertiesContext { + var p = new(Object_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_object_properties + + return p +} + +func (s *Object_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_propertiesContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPASSWORD, 0) +} + +func (s *Object_propertiesContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Object_propertiesContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Object_propertiesContext) LOGIN_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOGIN_NAME, 0) +} + +func (s *Object_propertiesContext) DISPLAY_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISPLAY_NAME, 0) +} + +func (s *Object_propertiesContext) FIRST_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIRST_NAME, 0) +} + +func (s *Object_propertiesContext) MIDDLE_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMIDDLE_NAME, 0) +} + +func (s *Object_propertiesContext) LAST_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST_NAME, 0) +} + +func (s *Object_propertiesContext) EMAIL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEMAIL, 0) +} + +func (s *Object_propertiesContext) MUST_CHANGE_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMUST_CHANGE_PASSWORD, 0) +} + +func (s *Object_propertiesContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Object_propertiesContext) DISABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLED, 0) +} + +func (s *Object_propertiesContext) DAYS_TO_EXPIRY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDAYS_TO_EXPIRY, 0) +} + +func (s *Object_propertiesContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Object_propertiesContext) MINS_TO_UNLOCK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINS_TO_UNLOCK, 0) +} + +func (s *Object_propertiesContext) DEFAULT_WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_WAREHOUSE, 0) +} + +func (s *Object_propertiesContext) DEFAULT_NAMESPACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_NAMESPACE, 0) +} + +func (s *Object_propertiesContext) DEFAULT_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_ROLE, 0) +} + +func (s *Object_propertiesContext) MINS_TO_BYPASS_MFA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINS_TO_BYPASS_MFA, 0) +} + +func (s *Object_propertiesContext) RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRSA_PUBLIC_KEY, 0) +} + +func (s *Object_propertiesContext) RSA_PUBLIC_KEY_2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRSA_PUBLIC_KEY_2, 0) +} + +func (s *Object_propertiesContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Object_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterObject_properties(s) + } +} + +func (s *Object_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_properties(s) + } +} + +func (s *Object_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_properties() (localctx IObject_propertiesContext) { + localctx = NewObject_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, SnowflakeParserRULE_object_properties) + p.SetState(2342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserPASSWORD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2290) + p.Match(SnowflakeParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2291) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2292) + p.String_() + } + + case SnowflakeParserLOGIN_NAME: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2293) + p.Match(SnowflakeParserLOGIN_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2294) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2295) + p.String_() + } + + case SnowflakeParserDISPLAY_NAME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2296) + p.Match(SnowflakeParserDISPLAY_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2297) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2298) + p.String_() + } + + case SnowflakeParserFIRST_NAME: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2299) + p.Match(SnowflakeParserFIRST_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2300) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2301) + p.String_() + } + + case SnowflakeParserMIDDLE_NAME: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2302) + p.Match(SnowflakeParserMIDDLE_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2303) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2304) + p.String_() + } + + case SnowflakeParserLAST_NAME: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2305) + p.Match(SnowflakeParserLAST_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2306) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2307) + p.String_() + } + + case SnowflakeParserEMAIL: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2308) + p.Match(SnowflakeParserEMAIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2309) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2310) + p.String_() + } + + case SnowflakeParserMUST_CHANGE_PASSWORD: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2311) + p.Match(SnowflakeParserMUST_CHANGE_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2312) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2313) + p.True_false() + } + + case SnowflakeParserDISABLED: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2314) + p.Match(SnowflakeParserDISABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2315) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2316) + p.True_false() + } + + case SnowflakeParserDAYS_TO_EXPIRY: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2317) + p.Match(SnowflakeParserDAYS_TO_EXPIRY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2318) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2319) + p.Num() + } + + case SnowflakeParserMINS_TO_UNLOCK: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2320) + p.Match(SnowflakeParserMINS_TO_UNLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2321) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2322) + p.Num() + } + + case SnowflakeParserDEFAULT_WAREHOUSE: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2323) + p.Match(SnowflakeParserDEFAULT_WAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2324) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2325) + p.String_() + } + + case SnowflakeParserDEFAULT_NAMESPACE: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2326) + p.Match(SnowflakeParserDEFAULT_NAMESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2327) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2328) + p.String_() + } + + case SnowflakeParserDEFAULT_ROLE: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2329) + p.Match(SnowflakeParserDEFAULT_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2330) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2331) + p.String_() + } + + case SnowflakeParserMINS_TO_BYPASS_MFA: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2332) + p.Match(SnowflakeParserMINS_TO_BYPASS_MFA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2333) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2334) + p.Num() + } + + case SnowflakeParserRSA_PUBLIC_KEY: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2335) + p.Match(SnowflakeParserRSA_PUBLIC_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2336) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2337) + p.String_() + } + + case SnowflakeParserRSA_PUBLIC_KEY_2: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2338) + p.Match(SnowflakeParserRSA_PUBLIC_KEY_2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2339) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2340) + p.String_() + } + + case SnowflakeParserCOMMENT: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2341) + p.Comment_clause() + } + + 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 +} + +// ISession_paramsContext is an interface to support dynamic dispatch. +type ISession_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT_DETACHED_QUERY() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + AUTOCOMMIT() antlr.TerminalNode + BINARY_INPUT_FORMAT() antlr.TerminalNode + String_() IStringContext + BINARY_OUTPUT_FORMAT() antlr.TerminalNode + DATE_INPUT_FORMAT() antlr.TerminalNode + DATE_OUTPUT_FORMAT() antlr.TerminalNode + ERROR_ON_NONDETERMINISTIC_MERGE() antlr.TerminalNode + ERROR_ON_NONDETERMINISTIC_UPDATE() antlr.TerminalNode + JSON_INDENT() antlr.TerminalNode + Num() INumContext + LOCK_TIMEOUT() antlr.TerminalNode + QUERY_TAG() antlr.TerminalNode + ROWS_PER_RESULTSET() antlr.TerminalNode + SIMULATED_DATA_SHARING_CONSUMER() antlr.TerminalNode + STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode + STRICT_JSON_OUTPUT() antlr.TerminalNode + TIMESTAMP_DAY_IS_ALWAYS_24H() antlr.TerminalNode + TIMESTAMP_INPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_LTZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_NTZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode + TIMESTAMP_TZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + TIME_INPUT_FORMAT() antlr.TerminalNode + TIME_OUTPUT_FORMAT() antlr.TerminalNode + TRANSACTION_DEFAULT_ISOLATION_LEVEL() antlr.TerminalNode + TWO_DIGIT_CENTURY_START() antlr.TerminalNode + UNSUPPORTED_DDL_ACTION() antlr.TerminalNode + USE_CACHED_RESULT() antlr.TerminalNode + WEEK_OF_YEAR_POLICY() antlr.TerminalNode + WEEK_START() antlr.TerminalNode + + // IsSession_paramsContext differentiates from other interfaces. + IsSession_paramsContext() +} + +type Session_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySession_paramsContext() *Session_paramsContext { + var p = new(Session_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_params + return p +} + +func InitEmptySession_paramsContext(p *Session_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_params +} + +func (*Session_paramsContext) IsSession_paramsContext() {} + +func NewSession_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Session_paramsContext { + var p = new(Session_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_session_params + + return p +} + +func (s *Session_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Session_paramsContext) ABORT_DETACHED_QUERY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT_DETACHED_QUERY, 0) +} + +func (s *Session_paramsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Session_paramsContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Session_paramsContext) AUTOCOMMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTOCOMMIT, 0) +} + +func (s *Session_paramsContext) BINARY_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_INPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Session_paramsContext) BINARY_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_OUTPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) DATE_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_INPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) DATE_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_OUTPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) ERROR_ON_NONDETERMINISTIC_MERGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, 0) +} + +func (s *Session_paramsContext) ERROR_ON_NONDETERMINISTIC_UPDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, 0) +} + +func (s *Session_paramsContext) JSON_INDENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON_INDENT, 0) +} + +func (s *Session_paramsContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Session_paramsContext) LOCK_TIMEOUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCK_TIMEOUT, 0) +} + +func (s *Session_paramsContext) QUERY_TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERY_TAG, 0) +} + +func (s *Session_paramsContext) ROWS_PER_RESULTSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWS_PER_RESULTSET, 0) +} + +func (s *Session_paramsContext) SIMULATED_DATA_SHARING_CONSUMER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, 0) +} + +func (s *Session_paramsContext) STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Session_paramsContext) STRICT_JSON_OUTPUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRICT_JSON_OUTPUT, 0) +} + +func (s *Session_paramsContext) TIMESTAMP_DAY_IS_ALWAYS_24H() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_DAY_IS_ALWAYS_24H, 0) +} + +func (s *Session_paramsContext) TIMESTAMP_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_INPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) TIMESTAMP_LTZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) TIMESTAMP_NTZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) TIMESTAMP_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_TYPE_MAPPING, 0) +} + +func (s *Session_paramsContext) TIMESTAMP_TZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEZONE, 0) +} + +func (s *Session_paramsContext) TIME_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME_INPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) TIME_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME_OUTPUT_FORMAT, 0) +} + +func (s *Session_paramsContext) TRANSACTION_DEFAULT_ISOLATION_LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, 0) +} + +func (s *Session_paramsContext) TWO_DIGIT_CENTURY_START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTWO_DIGIT_CENTURY_START, 0) +} + +func (s *Session_paramsContext) UNSUPPORTED_DDL_ACTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSUPPORTED_DDL_ACTION, 0) +} + +func (s *Session_paramsContext) USE_CACHED_RESULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE_CACHED_RESULT, 0) +} + +func (s *Session_paramsContext) WEEK_OF_YEAR_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWEEK_OF_YEAR_POLICY, 0) +} + +func (s *Session_paramsContext) WEEK_START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWEEK_START, 0) +} + +func (s *Session_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Session_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Session_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSession_params(s) + } +} + +func (s *Session_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSession_params(s) + } +} + +func (s *Session_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSession_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Session_params() (localctx ISession_paramsContext) { + localctx = NewSession_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, SnowflakeParserRULE_session_params) + p.SetState(2437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserABORT_DETACHED_QUERY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2344) + p.Match(SnowflakeParserABORT_DETACHED_QUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2345) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2346) + p.True_false() + } + + case SnowflakeParserAUTOCOMMIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2347) + p.Match(SnowflakeParserAUTOCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2348) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2349) + p.True_false() + } + + case SnowflakeParserBINARY_INPUT_FORMAT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2350) + p.Match(SnowflakeParserBINARY_INPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2351) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2352) + p.String_() + } + + case SnowflakeParserBINARY_OUTPUT_FORMAT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2353) + p.Match(SnowflakeParserBINARY_OUTPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2354) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2355) + p.String_() + } + + case SnowflakeParserDATE_INPUT_FORMAT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2356) + p.Match(SnowflakeParserDATE_INPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2357) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2358) + p.String_() + } + + case SnowflakeParserDATE_OUTPUT_FORMAT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2359) + p.Match(SnowflakeParserDATE_OUTPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2360) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2361) + p.String_() + } + + case SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2362) + p.Match(SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2363) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2364) + p.True_false() + } + + case SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2365) + p.Match(SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2366) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2367) + p.True_false() + } + + case SnowflakeParserJSON_INDENT: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2368) + p.Match(SnowflakeParserJSON_INDENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2369) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2370) + p.Num() + } + + case SnowflakeParserLOCK_TIMEOUT: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2371) + p.Match(SnowflakeParserLOCK_TIMEOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2372) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2373) + p.Num() + } + + case SnowflakeParserQUERY_TAG: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2374) + p.Match(SnowflakeParserQUERY_TAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2375) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2376) + p.String_() + } + + case SnowflakeParserROWS_PER_RESULTSET: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2377) + p.Match(SnowflakeParserROWS_PER_RESULTSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2378) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2379) + p.Num() + } + + case SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2380) + p.Match(SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2381) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2382) + p.String_() + } + + case SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2383) + p.Match(SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2384) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2385) + p.Num() + } + + case SnowflakeParserSTRICT_JSON_OUTPUT: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2386) + p.Match(SnowflakeParserSTRICT_JSON_OUTPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2387) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2388) + p.True_false() + } + + case SnowflakeParserTIMESTAMP_DAY_IS_ALWAYS_24H: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2389) + p.Match(SnowflakeParserTIMESTAMP_DAY_IS_ALWAYS_24H) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2390) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2391) + p.True_false() + } + + case SnowflakeParserTIMESTAMP_INPUT_FORMAT: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2392) + p.Match(SnowflakeParserTIMESTAMP_INPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2393) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2394) + p.String_() + } + + case SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2395) + p.Match(SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2396) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2397) + p.String_() + } + + case SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2398) + p.Match(SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2399) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2400) + p.String_() + } + + case SnowflakeParserTIMESTAMP_OUTPUT_FORMAT: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2401) + p.Match(SnowflakeParserTIMESTAMP_OUTPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2402) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2403) + p.String_() + } + + case SnowflakeParserTIMESTAMP_TYPE_MAPPING: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2404) + p.Match(SnowflakeParserTIMESTAMP_TYPE_MAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2405) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2406) + p.String_() + } + + case SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2407) + p.Match(SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2408) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2409) + p.String_() + } + + case SnowflakeParserTIMEZONE: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2410) + p.Match(SnowflakeParserTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2411) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2412) + p.String_() + } + + case SnowflakeParserTIME_INPUT_FORMAT: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2413) + p.Match(SnowflakeParserTIME_INPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2414) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2415) + p.String_() + } + + case SnowflakeParserTIME_OUTPUT_FORMAT: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2416) + p.Match(SnowflakeParserTIME_OUTPUT_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2417) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2418) + p.String_() + } + + case SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2419) + p.Match(SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2420) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2421) + p.String_() + } + + case SnowflakeParserTWO_DIGIT_CENTURY_START: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2422) + p.Match(SnowflakeParserTWO_DIGIT_CENTURY_START) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2423) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2424) + p.Num() + } + + case SnowflakeParserUNSUPPORTED_DDL_ACTION: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(2425) + p.Match(SnowflakeParserUNSUPPORTED_DDL_ACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2426) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2427) + p.String_() + } + + case SnowflakeParserUSE_CACHED_RESULT: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(2428) + p.Match(SnowflakeParserUSE_CACHED_RESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2429) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2430) + p.True_false() + } + + case SnowflakeParserWEEK_OF_YEAR_POLICY: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(2431) + p.Match(SnowflakeParserWEEK_OF_YEAR_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2432) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2433) + p.Num() + } + + case SnowflakeParserWEEK_START: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(2434) + p.Match(SnowflakeParserWEEK_START) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2435) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2436) + p.Num() + } + + 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_accountContext is an interface to support dynamic dispatch. +type IAlter_accountContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + Alter_account_opts() IAlter_account_optsContext + + // IsAlter_accountContext differentiates from other interfaces. + IsAlter_accountContext() +} + +type Alter_accountContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_accountContext() *Alter_accountContext { + var p = new(Alter_accountContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_account + return p +} + +func InitEmptyAlter_accountContext(p *Alter_accountContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_account +} + +func (*Alter_accountContext) IsAlter_accountContext() {} + +func NewAlter_accountContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_accountContext { + var p = new(Alter_accountContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_account + + return p +} + +func (s *Alter_accountContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_accountContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_accountContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Alter_accountContext) Alter_account_opts() IAlter_account_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_account_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_account_optsContext) +} + +func (s *Alter_accountContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_accountContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_accountContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_account(s) + } +} + +func (s *Alter_accountContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_account(s) + } +} + +func (s *Alter_accountContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_account(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_account() (localctx IAlter_accountContext) { + localctx = NewAlter_accountContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, SnowflakeParserRULE_alter_account) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2439) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2440) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2441) + p.Alter_account_opts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnabled_true_falseContext is an interface to support dynamic dispatch. +type IEnabled_true_falseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLED() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + + // IsEnabled_true_falseContext differentiates from other interfaces. + IsEnabled_true_falseContext() +} + +type Enabled_true_falseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnabled_true_falseContext() *Enabled_true_falseContext { + var p = new(Enabled_true_falseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_enabled_true_false + return p +} + +func InitEmptyEnabled_true_falseContext(p *Enabled_true_falseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_enabled_true_false +} + +func (*Enabled_true_falseContext) IsEnabled_true_falseContext() {} + +func NewEnabled_true_falseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enabled_true_falseContext { + var p = new(Enabled_true_falseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_enabled_true_false + + return p +} + +func (s *Enabled_true_falseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enabled_true_falseContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Enabled_true_falseContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Enabled_true_falseContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Enabled_true_falseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enabled_true_falseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enabled_true_falseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterEnabled_true_false(s) + } +} + +func (s *Enabled_true_falseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitEnabled_true_false(s) + } +} + +func (s *Enabled_true_falseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitEnabled_true_false(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Enabled_true_false() (localctx IEnabled_true_falseContext) { + localctx = NewEnabled_true_falseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, SnowflakeParserRULE_enabled_true_false) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2443) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2444) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2445) + p.True_false() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_alertContext is an interface to support dynamic dispatch. +type IAlter_alertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ALERT() antlr.TerminalNode + Id_() IId_Context + Resume_suspend() IResume_suspendContext + SET() antlr.TerminalNode + UNSET() antlr.TerminalNode + MODIFY() antlr.TerminalNode + CONDITION() antlr.TerminalNode + EXISTS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Alert_condition() IAlert_conditionContext + RR_BRACKET() antlr.TerminalNode + ACTION() antlr.TerminalNode + Alert_action() IAlert_actionContext + If_exists() IIf_existsContext + AllAlert_set_clause() []IAlert_set_clauseContext + Alert_set_clause(i int) IAlert_set_clauseContext + AllAlert_unset_clause() []IAlert_unset_clauseContext + Alert_unset_clause(i int) IAlert_unset_clauseContext + + // IsAlter_alertContext differentiates from other interfaces. + IsAlter_alertContext() +} + +type Alter_alertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_alertContext() *Alter_alertContext { + var p = new(Alter_alertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_alert + return p +} + +func InitEmptyAlter_alertContext(p *Alter_alertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_alert +} + +func (*Alter_alertContext) IsAlter_alertContext() {} + +func NewAlter_alertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_alertContext { + var p = new(Alter_alertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_alert + + return p +} + +func (s *Alter_alertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_alertContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_alertContext) ALERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERT, 0) +} + +func (s *Alter_alertContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_alertContext) Resume_suspend() IResume_suspendContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResume_suspendContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResume_suspendContext) +} + +func (s *Alter_alertContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_alertContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_alertContext) MODIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODIFY, 0) +} + +func (s *Alter_alertContext) CONDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONDITION, 0) +} + +func (s *Alter_alertContext) EXISTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXISTS, 0) +} + +func (s *Alter_alertContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_alertContext) Alert_condition() IAlert_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlert_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlert_conditionContext) +} + +func (s *Alter_alertContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_alertContext) ACTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACTION, 0) +} + +func (s *Alter_alertContext) Alert_action() IAlert_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlert_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlert_actionContext) +} + +func (s *Alter_alertContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_alertContext) AllAlert_set_clause() []IAlert_set_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlert_set_clauseContext); ok { + len++ + } + } + + tst := make([]IAlert_set_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlert_set_clauseContext); ok { + tst[i] = t.(IAlert_set_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_alertContext) Alert_set_clause(i int) IAlert_set_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlert_set_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlert_set_clauseContext) +} + +func (s *Alter_alertContext) AllAlert_unset_clause() []IAlert_unset_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlert_unset_clauseContext); ok { + len++ + } + } + + tst := make([]IAlert_unset_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlert_unset_clauseContext); ok { + tst[i] = t.(IAlert_unset_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_alertContext) Alert_unset_clause(i int) IAlert_unset_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlert_unset_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlert_unset_clauseContext) +} + +func (s *Alter_alertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_alertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_alertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_alert(s) + } +} + +func (s *Alter_alertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_alert(s) + } +} + +func (s *Alter_alertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_alert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_alert() (localctx IAlter_alertContext) { + localctx = NewAlter_alertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, SnowflakeParserRULE_alter_alert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2447) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2448) + p.Match(SnowflakeParserALERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2450) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 160, p.GetParserRuleContext()) == 1 { + { + p.SetState(2449) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2452) + p.Id_() + } + p.SetState(2476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 163, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2453) + p.Resume_suspend() + } + + case 2: + { + p.SetState(2454) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserCOMMENT || _la == SnowflakeParserSCHEDULE || _la == SnowflakeParserWAREHOUSE { + { + p.SetState(2455) + p.Alert_set_clause() + } + + p.SetState(2458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(2460) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserCOMMENT || _la == SnowflakeParserSCHEDULE || _la == SnowflakeParserWAREHOUSE { + { + p.SetState(2461) + p.Alert_unset_clause() + } + + p.SetState(2464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 4: + { + p.SetState(2466) + p.Match(SnowflakeParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2467) + p.Match(SnowflakeParserCONDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2468) + p.Match(SnowflakeParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2469) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2470) + p.Alert_condition() + } + { + p.SetState(2471) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(2473) + p.Match(SnowflakeParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2474) + p.Match(SnowflakeParserACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2475) + p.Alert_action() + } + + 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 +} + +// IResume_suspendContext is an interface to support dynamic dispatch. +type IResume_suspendContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESUME() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + + // IsResume_suspendContext differentiates from other interfaces. + IsResume_suspendContext() +} + +type Resume_suspendContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResume_suspendContext() *Resume_suspendContext { + var p = new(Resume_suspendContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_resume_suspend + return p +} + +func InitEmptyResume_suspendContext(p *Resume_suspendContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_resume_suspend +} + +func (*Resume_suspendContext) IsResume_suspendContext() {} + +func NewResume_suspendContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resume_suspendContext { + var p = new(Resume_suspendContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_resume_suspend + + return p +} + +func (s *Resume_suspendContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resume_suspendContext) RESUME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESUME, 0) +} + +func (s *Resume_suspendContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND, 0) +} + +func (s *Resume_suspendContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resume_suspendContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resume_suspendContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterResume_suspend(s) + } +} + +func (s *Resume_suspendContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitResume_suspend(s) + } +} + +func (s *Resume_suspendContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitResume_suspend(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Resume_suspend() (localctx IResume_suspendContext) { + localctx = NewResume_suspendContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, SnowflakeParserRULE_resume_suspend) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2478) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserRESUME || _la == SnowflakeParserSUSPEND) { + 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 +} + +// IAlert_set_clauseContext is an interface to support dynamic dispatch. +type IAlert_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAREHOUSE() antlr.TerminalNode + EQ() antlr.TerminalNode + Id_() IId_Context + SCHEDULE() antlr.TerminalNode + String_() IStringContext + Comment_clause() IComment_clauseContext + + // IsAlert_set_clauseContext differentiates from other interfaces. + IsAlert_set_clauseContext() +} + +type Alert_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlert_set_clauseContext() *Alert_set_clauseContext { + var p = new(Alert_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alert_set_clause + return p +} + +func InitEmptyAlert_set_clauseContext(p *Alert_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alert_set_clause +} + +func (*Alert_set_clauseContext) IsAlert_set_clauseContext() {} + +func NewAlert_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alert_set_clauseContext { + var p = new(Alert_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alert_set_clause + + return p +} + +func (s *Alert_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alert_set_clauseContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Alert_set_clauseContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Alert_set_clauseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alert_set_clauseContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEDULE, 0) +} + +func (s *Alert_set_clauseContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alert_set_clauseContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alert_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alert_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alert_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlert_set_clause(s) + } +} + +func (s *Alert_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlert_set_clause(s) + } +} + +func (s *Alert_set_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlert_set_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alert_set_clause() (localctx IAlert_set_clauseContext) { + localctx = NewAlert_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, SnowflakeParserRULE_alert_set_clause) + p.SetState(2487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserWAREHOUSE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2480) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2481) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2482) + p.Id_() + } + + case SnowflakeParserSCHEDULE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2483) + p.Match(SnowflakeParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2484) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2485) + p.String_() + } + + case SnowflakeParserCOMMENT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2486) + p.Comment_clause() + } + + 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 +} + +// IAlert_unset_clauseContext is an interface to support dynamic dispatch. +type IAlert_unset_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAREHOUSE() antlr.TerminalNode + SCHEDULE() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlert_unset_clauseContext differentiates from other interfaces. + IsAlert_unset_clauseContext() +} + +type Alert_unset_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlert_unset_clauseContext() *Alert_unset_clauseContext { + var p = new(Alert_unset_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alert_unset_clause + return p +} + +func InitEmptyAlert_unset_clauseContext(p *Alert_unset_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alert_unset_clause +} + +func (*Alert_unset_clauseContext) IsAlert_unset_clauseContext() {} + +func NewAlert_unset_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alert_unset_clauseContext { + var p = new(Alert_unset_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alert_unset_clause + + return p +} + +func (s *Alert_unset_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alert_unset_clauseContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Alert_unset_clauseContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEDULE, 0) +} + +func (s *Alert_unset_clauseContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alert_unset_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alert_unset_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alert_unset_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlert_unset_clause(s) + } +} + +func (s *Alert_unset_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlert_unset_clause(s) + } +} + +func (s *Alert_unset_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlert_unset_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alert_unset_clause() (localctx IAlert_unset_clauseContext) { + localctx = NewAlert_unset_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, SnowflakeParserRULE_alert_unset_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2489) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOMMENT || _la == SnowflakeParserSCHEDULE || _la == SnowflakeParserWAREHOUSE) { + 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 +} + +// IAlter_api_integrationContext is an interface to support dynamic dispatch. +type IAlter_api_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + SET() antlr.TerminalNode + API() antlr.TerminalNode + If_exists() IIf_existsContext + API_AWS_ROLE_ARN() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + AZURE_AD_APPLICATION_ID() antlr.TerminalNode + API_KEY() antlr.TerminalNode + Enabled_true_false() IEnabled_true_falseContext + API_ALLOWED_PREFIXES() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + API_BLOCKED_PREFIXES() antlr.TerminalNode + Comment_clause() IComment_clauseContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + AllApi_integration_property() []IApi_integration_propertyContext + Api_integration_property(i int) IApi_integration_propertyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_api_integrationContext differentiates from other interfaces. + IsAlter_api_integrationContext() +} + +type Alter_api_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_api_integrationContext() *Alter_api_integrationContext { + var p = new(Alter_api_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_api_integration + return p +} + +func InitEmptyAlter_api_integrationContext(p *Alter_api_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_api_integration +} + +func (*Alter_api_integrationContext) IsAlter_api_integrationContext() {} + +func NewAlter_api_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_api_integrationContext { + var p = new(Alter_api_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_api_integration + + return p +} + +func (s *Alter_api_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_api_integrationContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_api_integrationContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Alter_api_integrationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_api_integrationContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_api_integrationContext) API() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI, 0) +} + +func (s *Alter_api_integrationContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_api_integrationContext) API_AWS_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_AWS_ROLE_ARN, 0) +} + +func (s *Alter_api_integrationContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_api_integrationContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_api_integrationContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_api_integrationContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_api_integrationContext) AZURE_AD_APPLICATION_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_AD_APPLICATION_ID, 0) +} + +func (s *Alter_api_integrationContext) API_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_KEY, 0) +} + +func (s *Alter_api_integrationContext) Enabled_true_false() IEnabled_true_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnabled_true_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnabled_true_falseContext) +} + +func (s *Alter_api_integrationContext) API_ALLOWED_PREFIXES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_ALLOWED_PREFIXES, 0) +} + +func (s *Alter_api_integrationContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Alter_api_integrationContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Alter_api_integrationContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Alter_api_integrationContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Alter_api_integrationContext) API_BLOCKED_PREFIXES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_BLOCKED_PREFIXES, 0) +} + +func (s *Alter_api_integrationContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_api_integrationContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_api_integrationContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_api_integrationContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_api_integrationContext) AllApi_integration_property() []IApi_integration_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IApi_integration_propertyContext); ok { + len++ + } + } + + tst := make([]IApi_integration_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IApi_integration_propertyContext); ok { + tst[i] = t.(IApi_integration_propertyContext) + i++ + } + } + + return tst +} + +func (s *Alter_api_integrationContext) Api_integration_property(i int) IApi_integration_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IApi_integration_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IApi_integration_propertyContext) +} + +func (s *Alter_api_integrationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_api_integrationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_api_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_api_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_api_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_api_integration(s) + } +} + +func (s *Alter_api_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_api_integration(s) + } +} + +func (s *Alter_api_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_api_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_api_integration() (localctx IAlter_api_integrationContext) { + localctx = NewAlter_api_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, SnowflakeParserRULE_alter_api_integration) + var _la int + + p.SetState(2572) + 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(2491) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI { + { + p.SetState(2492) + p.Match(SnowflakeParserAPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2495) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2497) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 166, p.GetParserRuleContext()) == 1 { + { + p.SetState(2496) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2499) + p.Id_() + } + { + p.SetState(2500) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_AWS_ROLE_ARN { + { + p.SetState(2501) + p.Match(SnowflakeParserAPI_AWS_ROLE_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2502) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2503) + p.String_() + } + + } + p.SetState(2509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAZURE_AD_APPLICATION_ID { + { + p.SetState(2506) + p.Match(SnowflakeParserAZURE_AD_APPLICATION_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2507) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2508) + p.String_() + } + + } + p.SetState(2514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_KEY { + { + p.SetState(2511) + p.Match(SnowflakeParserAPI_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2512) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2513) + p.String_() + } + + } + p.SetState(2517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(2516) + p.Enabled_true_false() + } + + } + p.SetState(2525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_ALLOWED_PREFIXES { + { + p.SetState(2519) + p.Match(SnowflakeParserAPI_ALLOWED_PREFIXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2520) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2521) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2522) + p.String_() + } + { + p.SetState(2523) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_BLOCKED_PREFIXES { + { + p.SetState(2527) + p.Match(SnowflakeParserAPI_BLOCKED_PREFIXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2528) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2529) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2530) + p.String_() + } + { + p.SetState(2531) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(2535) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2538) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI { + { + p.SetState(2539) + p.Match(SnowflakeParserAPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2542) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2543) + p.Id_() + } + { + p.SetState(2544) + p.Set_tags() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2546) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI { + { + p.SetState(2547) + p.Match(SnowflakeParserAPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2550) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2551) + p.Id_() + } + { + p.SetState(2552) + p.Unset_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2554) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI { + { + p.SetState(2555) + p.Match(SnowflakeParserAPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(2558) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2560) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 177, p.GetParserRuleContext()) == 1 { + { + p.SetState(2559) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2562) + p.Id_() + } + { + p.SetState(2563) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2564) + p.Api_integration_property() + } + p.SetState(2569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2565) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2566) + p.Api_integration_property() + } + + p.SetState(2571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + 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 +} + +// IApi_integration_propertyContext is an interface to support dynamic dispatch. +type IApi_integration_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + API_KEY() antlr.TerminalNode + ENABLED() antlr.TerminalNode + API_BLOCKED_PREFIXES() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsApi_integration_propertyContext differentiates from other interfaces. + IsApi_integration_propertyContext() +} + +type Api_integration_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyApi_integration_propertyContext() *Api_integration_propertyContext { + var p = new(Api_integration_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_api_integration_property + return p +} + +func InitEmptyApi_integration_propertyContext(p *Api_integration_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_api_integration_property +} + +func (*Api_integration_propertyContext) IsApi_integration_propertyContext() {} + +func NewApi_integration_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Api_integration_propertyContext { + var p = new(Api_integration_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_api_integration_property + + return p +} + +func (s *Api_integration_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Api_integration_propertyContext) API_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_KEY, 0) +} + +func (s *Api_integration_propertyContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Api_integration_propertyContext) API_BLOCKED_PREFIXES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_BLOCKED_PREFIXES, 0) +} + +func (s *Api_integration_propertyContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Api_integration_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Api_integration_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Api_integration_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterApi_integration_property(s) + } +} + +func (s *Api_integration_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitApi_integration_property(s) + } +} + +func (s *Api_integration_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitApi_integration_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Api_integration_property() (localctx IApi_integration_propertyContext) { + localctx = NewApi_integration_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, SnowflakeParserRULE_api_integration_property) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2574) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAPI_BLOCKED_PREFIXES || _la == SnowflakeParserAPI_KEY || _la == SnowflakeParserCOMMENT || _la == SnowflakeParserENABLED) { + 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 +} + +// IAlter_connectionContext is an interface to support dynamic dispatch. +type IAlter_connectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + Alter_connection_opts() IAlter_connection_optsContext + + // IsAlter_connectionContext differentiates from other interfaces. + IsAlter_connectionContext() +} + +type Alter_connectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_connectionContext() *Alter_connectionContext { + var p = new(Alter_connectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_connection + return p +} + +func InitEmptyAlter_connectionContext(p *Alter_connectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_connection +} + +func (*Alter_connectionContext) IsAlter_connectionContext() {} + +func NewAlter_connectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_connectionContext { + var p = new(Alter_connectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_connection + + return p +} + +func (s *Alter_connectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_connectionContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_connectionContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONNECTION, 0) +} + +func (s *Alter_connectionContext) Alter_connection_opts() IAlter_connection_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_connection_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_connection_optsContext) +} + +func (s *Alter_connectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_connectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_connectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_connection(s) + } +} + +func (s *Alter_connectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_connection(s) + } +} + +func (s *Alter_connectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_connection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_connection() (localctx IAlter_connectionContext) { + localctx = NewAlter_connectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, SnowflakeParserRULE_alter_connection) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2576) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2577) + p.Match(SnowflakeParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2578) + p.Alter_connection_opts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_databaseContext is an interface to support dynamic dispatch. +type IAlter_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SWAP() antlr.TerminalNode + WITH() antlr.TerminalNode + SET() antlr.TerminalNode + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + Default_ddl_collation() IDefault_ddl_collationContext + Comment_clause() IComment_clauseContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + AllDatabase_property() []IDatabase_propertyContext + Database_property(i int) IDatabase_propertyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ENABLE() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + ACCOUNTS() antlr.TerminalNode + Account_id_list() IAccount_id_listContext + IGNORE() antlr.TerminalNode + EDITION() antlr.TerminalNode + CHECK() antlr.TerminalNode + DISABLE() antlr.TerminalNode + REFRESH() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + + // IsAlter_databaseContext differentiates from other interfaces. + IsAlter_databaseContext() +} + +type Alter_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_databaseContext() *Alter_databaseContext { + var p = new(Alter_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_database + return p +} + +func InitEmptyAlter_databaseContext(p *Alter_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_database +} + +func (*Alter_databaseContext) IsAlter_databaseContext() {} + +func NewAlter_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_databaseContext { + var p = new(Alter_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_database + + return p +} + +func (s *Alter_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_databaseContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Alter_databaseContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_databaseContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_databaseContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_databaseContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_databaseContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_databaseContext) SWAP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSWAP, 0) +} + +func (s *Alter_databaseContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Alter_databaseContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_databaseContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Alter_databaseContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_databaseContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_databaseContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Alter_databaseContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Alter_databaseContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Alter_databaseContext) Default_ddl_collation() IDefault_ddl_collationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_ddl_collationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_ddl_collationContext) +} + +func (s *Alter_databaseContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_databaseContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_databaseContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_databaseContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_databaseContext) AllDatabase_property() []IDatabase_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatabase_propertyContext); ok { + len++ + } + } + + tst := make([]IDatabase_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatabase_propertyContext); ok { + tst[i] = t.(IDatabase_propertyContext) + i++ + } + } + + return tst +} + +func (s *Alter_databaseContext) Database_property(i int) IDatabase_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_propertyContext) +} + +func (s *Alter_databaseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_databaseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_databaseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *Alter_databaseContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Alter_databaseContext) ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTS, 0) +} + +func (s *Alter_databaseContext) Account_id_list() IAccount_id_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccount_id_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccount_id_listContext) +} + +func (s *Alter_databaseContext) IGNORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE, 0) +} + +func (s *Alter_databaseContext) EDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEDITION, 0) +} + +func (s *Alter_databaseContext) CHECK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHECK, 0) +} + +func (s *Alter_databaseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE, 0) +} + +func (s *Alter_databaseContext) REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH, 0) +} + +func (s *Alter_databaseContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, 0) +} + +func (s *Alter_databaseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Alter_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_database(s) + } +} + +func (s *Alter_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_database(s) + } +} + +func (s *Alter_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_database() (localctx IAlter_databaseContext) { + localctx = NewAlter_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, SnowflakeParserRULE_alter_database) + var _la int + + p.SetState(2700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 192, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2580) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2581) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2583) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 180, p.GetParserRuleContext()) == 1 { + { + p.SetState(2582) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2585) + p.Id_() + } + { + p.SetState(2586) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2587) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2588) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2590) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2591) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2593) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 181, p.GetParserRuleContext()) == 1 { + { + p.SetState(2592) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2595) + p.Id_() + } + { + p.SetState(2596) + p.Match(SnowflakeParserSWAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2597) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2598) + p.Id_() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2600) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2601) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2603) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 182, p.GetParserRuleContext()) == 1 { + { + p.SetState(2602) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2605) + p.Id_() + } + { + p.SetState(2606) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDATA_RETENTION_TIME_IN_DAYS { + { + p.SetState(2607) + p.Match(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2608) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2609) + p.Num() + } + + } + p.SetState(2615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS { + { + p.SetState(2612) + p.Match(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2613) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2614) + p.Num() + } + + } + p.SetState(2618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDEFAULT_DDL_COLLATION_ { + { + p.SetState(2617) + p.Default_ddl_collation() + } + + } + p.SetState(2621) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(2620) + p.Comment_clause() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2623) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2624) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2625) + p.Id_() + } + { + p.SetState(2626) + p.Set_tags() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2628) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2629) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2630) + p.Id_() + } + { + p.SetState(2631) + p.Unset_tags() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2633) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2634) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2636) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 187, p.GetParserRuleContext()) == 1 { + { + p.SetState(2635) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2638) + p.Id_() + } + { + p.SetState(2639) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2640) + p.Database_property() + } + p.SetState(2645) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2641) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2642) + p.Database_property() + } + + p.SetState(2647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2648) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2649) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2650) + p.Id_() + } + { + p.SetState(2651) + p.Match(SnowflakeParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2652) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2653) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2654) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2655) + p.Account_id_list() + } + p.SetState(2659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIGNORE { + { + p.SetState(2656) + p.Match(SnowflakeParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2657) + p.Match(SnowflakeParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2658) + p.Match(SnowflakeParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2661) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2662) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2663) + p.Id_() + } + { + p.SetState(2664) + p.Match(SnowflakeParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2665) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTO { + { + p.SetState(2666) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2667) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2668) + p.Account_id_list() + } + + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2671) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2672) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2673) + p.Id_() + } + { + p.SetState(2674) + p.Match(SnowflakeParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2676) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2677) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2678) + p.Id_() + } + { + p.SetState(2679) + p.Match(SnowflakeParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2680) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2681) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2682) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2683) + p.Account_id_list() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2685) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2686) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2687) + p.Id_() + } + { + p.SetState(2688) + p.Match(SnowflakeParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2689) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTO { + { + p.SetState(2690) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2691) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2692) + p.Account_id_list() + } + + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2695) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2696) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2697) + p.Id_() + } + { + p.SetState(2698) + p.Match(SnowflakeParserPRIMARY) + 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 +} + +// IDatabase_propertyContext is an interface to support dynamic dispatch. +type IDatabase_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + DEFAULT_DDL_COLLATION_() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsDatabase_propertyContext differentiates from other interfaces. + IsDatabase_propertyContext() +} + +type Database_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_propertyContext() *Database_propertyContext { + var p = new(Database_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_database_property + return p +} + +func InitEmptyDatabase_propertyContext(p *Database_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_database_property +} + +func (*Database_propertyContext) IsDatabase_propertyContext() {} + +func NewDatabase_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_propertyContext { + var p = new(Database_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_database_property + + return p +} + +func (s *Database_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_propertyContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Database_propertyContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Database_propertyContext) DEFAULT_DDL_COLLATION_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_DDL_COLLATION_, 0) +} + +func (s *Database_propertyContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Database_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDatabase_property(s) + } +} + +func (s *Database_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDatabase_property(s) + } +} + +func (s *Database_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDatabase_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Database_property() (localctx IDatabase_propertyContext) { + localctx = NewDatabase_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, SnowflakeParserRULE_database_property) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2702) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-161)) & ^0x3f) == 0 && ((int64(1)<<(_la-161))&2306124484190404609) != 0) || _la == SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) { + 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 +} + +// IAccount_id_listContext is an interface to support dynamic dispatch. +type IAccount_id_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAccount_identifier() []IAccount_identifierContext + Account_identifier(i int) IAccount_identifierContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAccount_id_listContext differentiates from other interfaces. + IsAccount_id_listContext() +} + +type Account_id_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccount_id_listContext() *Account_id_listContext { + var p = new(Account_id_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_id_list + return p +} + +func InitEmptyAccount_id_listContext(p *Account_id_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_id_list +} + +func (*Account_id_listContext) IsAccount_id_listContext() {} + +func NewAccount_id_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Account_id_listContext { + var p = new(Account_id_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_account_id_list + + return p +} + +func (s *Account_id_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Account_id_listContext) AllAccount_identifier() []IAccount_identifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAccount_identifierContext); ok { + len++ + } + } + + tst := make([]IAccount_identifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAccount_identifierContext); ok { + tst[i] = t.(IAccount_identifierContext) + i++ + } + } + + return tst +} + +func (s *Account_id_listContext) Account_identifier(i int) IAccount_identifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccount_identifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAccount_identifierContext) +} + +func (s *Account_id_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Account_id_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Account_id_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Account_id_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Account_id_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAccount_id_list(s) + } +} + +func (s *Account_id_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAccount_id_list(s) + } +} + +func (s *Account_id_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAccount_id_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Account_id_list() (localctx IAccount_id_listContext) { + localctx = NewAccount_id_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, SnowflakeParserRULE_account_id_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2704) + p.Account_identifier() + } + p.SetState(2709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2705) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2706) + p.Account_identifier() + } + + p.SetState(2711) + 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_dynamic_tableContext is an interface to support dynamic dispatch. +type IAlter_dynamic_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + Resume_suspend() IResume_suspendContext + REFRESH() antlr.TerminalNode + SET() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + EQ() antlr.TerminalNode + + // IsAlter_dynamic_tableContext differentiates from other interfaces. + IsAlter_dynamic_tableContext() +} + +type Alter_dynamic_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_dynamic_tableContext() *Alter_dynamic_tableContext { + var p = new(Alter_dynamic_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_dynamic_table + return p +} + +func InitEmptyAlter_dynamic_tableContext(p *Alter_dynamic_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_dynamic_table +} + +func (*Alter_dynamic_tableContext) IsAlter_dynamic_tableContext() {} + +func NewAlter_dynamic_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_dynamic_tableContext { + var p = new(Alter_dynamic_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_dynamic_table + + return p +} + +func (s *Alter_dynamic_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_dynamic_tableContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_dynamic_tableContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDYNAMIC, 0) +} + +func (s *Alter_dynamic_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Alter_dynamic_tableContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_dynamic_tableContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_dynamic_tableContext) Resume_suspend() IResume_suspendContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResume_suspendContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResume_suspendContext) +} + +func (s *Alter_dynamic_tableContext) REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH, 0) +} + +func (s *Alter_dynamic_tableContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_dynamic_tableContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Alter_dynamic_tableContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Alter_dynamic_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_dynamic_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_dynamic_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_dynamic_table(s) + } +} + +func (s *Alter_dynamic_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_dynamic_table(s) + } +} + +func (s *Alter_dynamic_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_dynamic_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_dynamic_table() (localctx IAlter_dynamic_tableContext) { + localctx = NewAlter_dynamic_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, SnowflakeParserRULE_alter_dynamic_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2712) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2713) + p.Match(SnowflakeParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2714) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2715) + p.Id_() + } + p.SetState(2722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserRESUME, SnowflakeParserSUSPEND: + { + p.SetState(2716) + p.Resume_suspend() + } + + case SnowflakeParserREFRESH: + { + p.SetState(2717) + p.Match(SnowflakeParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSET: + { + p.SetState(2718) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2719) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2720) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2721) + p.Id_() + } + + 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_external_tableContext is an interface to support dynamic dispatch. +type IAlter_external_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + REFRESH() antlr.TerminalNode + If_exists() IIf_existsContext + AllString_() []IStringContext + String_(i int) IStringContext + ADD() antlr.TerminalNode + FILES() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + String_list() IString_listContext + RR_BRACKET() antlr.TerminalNode + REMOVE() antlr.TerminalNode + SET() antlr.TerminalNode + AUTO_REFRESH() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + True_false() ITrue_falseContext + Tag_decl_list() ITag_decl_listContext + Unset_tags() IUnset_tagsContext + PARTITION() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + LOCATION() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAlter_external_tableContext differentiates from other interfaces. + IsAlter_external_tableContext() +} + +type Alter_external_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_external_tableContext() *Alter_external_tableContext { + var p = new(Alter_external_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_external_table + return p +} + +func InitEmptyAlter_external_tableContext(p *Alter_external_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_external_table +} + +func (*Alter_external_tableContext) IsAlter_external_tableContext() {} + +func NewAlter_external_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_external_tableContext { + var p = new(Alter_external_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_external_table + + return p +} + +func (s *Alter_external_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_external_tableContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_external_tableContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Alter_external_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Alter_external_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Alter_external_tableContext) REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH, 0) +} + +func (s *Alter_external_tableContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_external_tableContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_external_tableContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_external_tableContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_external_tableContext) FILES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILES, 0) +} + +func (s *Alter_external_tableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_external_tableContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Alter_external_tableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_external_tableContext) REMOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOVE, 0) +} + +func (s *Alter_external_tableContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_external_tableContext) AUTO_REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_REFRESH, 0) +} + +func (s *Alter_external_tableContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_external_tableContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_external_tableContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_external_tableContext) Tag_decl_list() ITag_decl_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITag_decl_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITag_decl_listContext) +} + +func (s *Alter_external_tableContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_external_tableContext) PARTITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARTITION, 0) +} + +func (s *Alter_external_tableContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_external_tableContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Alter_external_tableContext) LOCATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCATION, 0) +} + +func (s *Alter_external_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_external_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_external_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Alter_external_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_external_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_external_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_external_table(s) + } +} + +func (s *Alter_external_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_external_table(s) + } +} + +func (s *Alter_external_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_external_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_external_table() (localctx IAlter_external_tableContext) { + localctx = NewAlter_external_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, SnowflakeParserRULE_alter_external_table) + var _la int + + p.SetState(2825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 206, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2724) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2725) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2726) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2728) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 195, p.GetParserRuleContext()) == 1 { + { + p.SetState(2727) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2730) + p.Object_name() + } + { + p.SetState(2731) + p.Match(SnowflakeParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTRING { + { + p.SetState(2732) + p.String_() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2735) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2736) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2737) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2739) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 197, p.GetParserRuleContext()) == 1 { + { + p.SetState(2738) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2741) + p.Object_name() + } + { + p.SetState(2742) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2743) + p.Match(SnowflakeParserFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2744) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2745) + p.String_list() + } + { + p.SetState(2746) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2748) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2749) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2750) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2752) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 198, p.GetParserRuleContext()) == 1 { + { + p.SetState(2751) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2754) + p.Object_name() + } + { + p.SetState(2755) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2756) + p.Match(SnowflakeParserFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2757) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2758) + p.String_list() + } + { + p.SetState(2759) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2761) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2762) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2763) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2765) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 199, p.GetParserRuleContext()) == 1 { + { + p.SetState(2764) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2767) + p.Object_name() + } + { + p.SetState(2768) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAUTO_REFRESH { + { + p.SetState(2769) + p.Match(SnowflakeParserAUTO_REFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2770) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2771) + p.True_false() + } + + } + p.SetState(2775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG { + { + p.SetState(2774) + p.Tag_decl_list() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2777) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2778) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2779) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2781) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 202, p.GetParserRuleContext()) == 1 { + { + p.SetState(2780) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2783) + p.Object_name() + } + { + p.SetState(2784) + p.Unset_tags() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2786) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2787) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2788) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2789) + p.Object_name() + } + p.SetState(2791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIF { + { + p.SetState(2790) + p.If_exists() + } + + } + { + p.SetState(2793) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2794) + p.Match(SnowflakeParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2795) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2796) + p.Column_name() + } + { + p.SetState(2797) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2798) + p.String_() + } + p.SetState(2806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2799) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2800) + p.Column_name() + } + { + p.SetState(2801) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2802) + p.String_() + } + + p.SetState(2808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(2809) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2810) + p.Match(SnowflakeParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2811) + p.String_() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2813) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2814) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2815) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2816) + p.Object_name() + } + p.SetState(2818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIF { + { + p.SetState(2817) + p.If_exists() + } + + } + { + p.SetState(2820) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2821) + p.Match(SnowflakeParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2822) + p.Match(SnowflakeParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2823) + p.String_() + } + + 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 +} + +// IIgnore_edition_checkContext is an interface to support dynamic dispatch. +type IIgnore_edition_checkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IGNORE() antlr.TerminalNode + EDITION() antlr.TerminalNode + CHECK() antlr.TerminalNode + + // IsIgnore_edition_checkContext differentiates from other interfaces. + IsIgnore_edition_checkContext() +} + +type Ignore_edition_checkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIgnore_edition_checkContext() *Ignore_edition_checkContext { + var p = new(Ignore_edition_checkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ignore_edition_check + return p +} + +func InitEmptyIgnore_edition_checkContext(p *Ignore_edition_checkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ignore_edition_check +} + +func (*Ignore_edition_checkContext) IsIgnore_edition_checkContext() {} + +func NewIgnore_edition_checkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ignore_edition_checkContext { + var p = new(Ignore_edition_checkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_ignore_edition_check + + return p +} + +func (s *Ignore_edition_checkContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ignore_edition_checkContext) IGNORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE, 0) +} + +func (s *Ignore_edition_checkContext) EDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEDITION, 0) +} + +func (s *Ignore_edition_checkContext) CHECK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHECK, 0) +} + +func (s *Ignore_edition_checkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ignore_edition_checkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ignore_edition_checkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIgnore_edition_check(s) + } +} + +func (s *Ignore_edition_checkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIgnore_edition_check(s) + } +} + +func (s *Ignore_edition_checkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIgnore_edition_check(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Ignore_edition_check() (localctx IIgnore_edition_checkContext) { + localctx = NewIgnore_edition_checkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, SnowflakeParserRULE_ignore_edition_check) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2827) + p.Match(SnowflakeParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2828) + p.Match(SnowflakeParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2829) + p.Match(SnowflakeParserCHECK) + 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 +} + +// IReplication_scheduleContext is an interface to support dynamic dispatch. +type IReplication_scheduleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLICATION_SCHEDULE() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsReplication_scheduleContext differentiates from other interfaces. + IsReplication_scheduleContext() +} + +type Replication_scheduleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplication_scheduleContext() *Replication_scheduleContext { + var p = new(Replication_scheduleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_replication_schedule + return p +} + +func InitEmptyReplication_scheduleContext(p *Replication_scheduleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_replication_schedule +} + +func (*Replication_scheduleContext) IsReplication_scheduleContext() {} + +func NewReplication_scheduleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replication_scheduleContext { + var p = new(Replication_scheduleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_replication_schedule + + return p +} + +func (s *Replication_scheduleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replication_scheduleContext) REPLICATION_SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION_SCHEDULE, 0) +} + +func (s *Replication_scheduleContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Replication_scheduleContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Replication_scheduleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replication_scheduleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replication_scheduleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterReplication_schedule(s) + } +} + +func (s *Replication_scheduleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitReplication_schedule(s) + } +} + +func (s *Replication_scheduleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitReplication_schedule(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Replication_schedule() (localctx IReplication_scheduleContext) { + localctx = NewReplication_scheduleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, SnowflakeParserRULE_replication_schedule) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2831) + p.Match(SnowflakeParserREPLICATION_SCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2832) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2833) + p.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 +} + +// IDb_name_listContext is an interface to support dynamic dispatch. +type IDb_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDb_name_listContext differentiates from other interfaces. + IsDb_name_listContext() +} + +type Db_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDb_name_listContext() *Db_name_listContext { + var p = new(Db_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_db_name_list + return p +} + +func InitEmptyDb_name_listContext(p *Db_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_db_name_list +} + +func (*Db_name_listContext) IsDb_name_listContext() {} + +func NewDb_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_name_listContext { + var p = new(Db_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_db_name_list + + return p +} + +func (s *Db_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Db_name_listContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Db_name_listContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Db_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Db_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Db_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Db_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Db_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDb_name_list(s) + } +} + +func (s *Db_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDb_name_list(s) + } +} + +func (s *Db_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDb_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Db_name_list() (localctx IDb_name_listContext) { + localctx = NewDb_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, SnowflakeParserRULE_db_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2835) + p.Id_() + } + p.SetState(2840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2836) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2837) + p.Id_() + } + + p.SetState(2842) + 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 +} + +// IShare_name_listContext is an interface to support dynamic dispatch. +type IShare_name_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsShare_name_listContext differentiates from other interfaces. + IsShare_name_listContext() +} + +type Share_name_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShare_name_listContext() *Share_name_listContext { + var p = new(Share_name_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_share_name_list + return p +} + +func InitEmptyShare_name_listContext(p *Share_name_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_share_name_list +} + +func (*Share_name_listContext) IsShare_name_listContext() {} + +func NewShare_name_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Share_name_listContext { + var p = new(Share_name_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_share_name_list + + return p +} + +func (s *Share_name_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Share_name_listContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Share_name_listContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Share_name_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Share_name_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Share_name_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Share_name_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Share_name_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShare_name_list(s) + } +} + +func (s *Share_name_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShare_name_list(s) + } +} + +func (s *Share_name_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShare_name_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Share_name_list() (localctx IShare_name_listContext) { + localctx = NewShare_name_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, SnowflakeParserRULE_share_name_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2843) + p.Id_() + } + p.SetState(2848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2844) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2845) + p.Id_() + } + + p.SetState(2850) + 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 +} + +// IFull_acct_listContext is an interface to support dynamic dispatch. +type IFull_acct_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFull_acct() []IFull_acctContext + Full_acct(i int) IFull_acctContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFull_acct_listContext differentiates from other interfaces. + IsFull_acct_listContext() +} + +type Full_acct_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFull_acct_listContext() *Full_acct_listContext { + var p = new(Full_acct_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_full_acct_list + return p +} + +func InitEmptyFull_acct_listContext(p *Full_acct_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_full_acct_list +} + +func (*Full_acct_listContext) IsFull_acct_listContext() {} + +func NewFull_acct_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_acct_listContext { + var p = new(Full_acct_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_full_acct_list + + return p +} + +func (s *Full_acct_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_acct_listContext) AllFull_acct() []IFull_acctContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFull_acctContext); ok { + len++ + } + } + + tst := make([]IFull_acctContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFull_acctContext); ok { + tst[i] = t.(IFull_acctContext) + i++ + } + } + + return tst +} + +func (s *Full_acct_listContext) Full_acct(i int) IFull_acctContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_acctContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFull_acctContext) +} + +func (s *Full_acct_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Full_acct_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Full_acct_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_acct_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_acct_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFull_acct_list(s) + } +} + +func (s *Full_acct_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFull_acct_list(s) + } +} + +func (s *Full_acct_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFull_acct_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Full_acct_list() (localctx IFull_acct_listContext) { + localctx = NewFull_acct_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, SnowflakeParserRULE_full_acct_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2851) + p.Full_acct() + } + p.SetState(2856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(2852) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2853) + p.Full_acct() + } + + p.SetState(2858) + 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_failover_groupContext is an interface to support dynamic dispatch. +type IAlter_failover_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AllFAILOVER() []antlr.TerminalNode + FAILOVER(i int) antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SET() antlr.TerminalNode + OBJECT_TYPES() antlr.TerminalNode + EQ() antlr.TerminalNode + Object_type_list() IObject_type_listContext + Replication_schedule() IReplication_scheduleContext + ADD() antlr.TerminalNode + Db_name_list() IDb_name_listContext + ALLOWED_DATABASES() antlr.TerminalNode + MOVE() antlr.TerminalNode + DATABASES() antlr.TerminalNode + REMOVE() antlr.TerminalNode + FROM() antlr.TerminalNode + Share_name_list() IShare_name_listContext + ALLOWED_SHARES() antlr.TerminalNode + SHARES() antlr.TerminalNode + Full_acct_list() IFull_acct_listContext + ALLOWED_ACCOUNTS() antlr.TerminalNode + Ignore_edition_check() IIgnore_edition_checkContext + REFRESH() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + RESUME() antlr.TerminalNode + + // IsAlter_failover_groupContext differentiates from other interfaces. + IsAlter_failover_groupContext() +} + +type Alter_failover_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_failover_groupContext() *Alter_failover_groupContext { + var p = new(Alter_failover_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_failover_group + return p +} + +func InitEmptyAlter_failover_groupContext(p *Alter_failover_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_failover_group +} + +func (*Alter_failover_groupContext) IsAlter_failover_groupContext() {} + +func NewAlter_failover_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_failover_groupContext { + var p = new(Alter_failover_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_failover_group + + return p +} + +func (s *Alter_failover_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_failover_groupContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_failover_groupContext) AllFAILOVER() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserFAILOVER) +} + +func (s *Alter_failover_groupContext) FAILOVER(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, i) +} + +func (s *Alter_failover_groupContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserGROUP) +} + +func (s *Alter_failover_groupContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, i) +} + +func (s *Alter_failover_groupContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_failover_groupContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_failover_groupContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_failover_groupContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_failover_groupContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_failover_groupContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_failover_groupContext) OBJECT_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT_TYPES, 0) +} + +func (s *Alter_failover_groupContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Alter_failover_groupContext) Object_type_list() IObject_type_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_listContext) +} + +func (s *Alter_failover_groupContext) Replication_schedule() IReplication_scheduleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplication_scheduleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplication_scheduleContext) +} + +func (s *Alter_failover_groupContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_failover_groupContext) Db_name_list() IDb_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDb_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDb_name_listContext) +} + +func (s *Alter_failover_groupContext) ALLOWED_DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_DATABASES, 0) +} + +func (s *Alter_failover_groupContext) MOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMOVE, 0) +} + +func (s *Alter_failover_groupContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Alter_failover_groupContext) REMOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOVE, 0) +} + +func (s *Alter_failover_groupContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Alter_failover_groupContext) Share_name_list() IShare_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShare_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShare_name_listContext) +} + +func (s *Alter_failover_groupContext) ALLOWED_SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_SHARES, 0) +} + +func (s *Alter_failover_groupContext) SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARES, 0) +} + +func (s *Alter_failover_groupContext) Full_acct_list() IFull_acct_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_acct_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_acct_listContext) +} + +func (s *Alter_failover_groupContext) ALLOWED_ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_ACCOUNTS, 0) +} + +func (s *Alter_failover_groupContext) Ignore_edition_check() IIgnore_edition_checkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIgnore_edition_checkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIgnore_edition_checkContext) +} + +func (s *Alter_failover_groupContext) REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH, 0) +} + +func (s *Alter_failover_groupContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Alter_failover_groupContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND, 0) +} + +func (s *Alter_failover_groupContext) RESUME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESUME, 0) +} + +func (s *Alter_failover_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_failover_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_failover_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_failover_group(s) + } +} + +func (s *Alter_failover_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_failover_group(s) + } +} + +func (s *Alter_failover_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_failover_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_failover_group() (localctx IAlter_failover_groupContext) { + localctx = NewAlter_failover_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, SnowflakeParserRULE_alter_failover_group) + var _la int + + p.SetState(3013) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 226, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2859) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2860) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2861) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2863) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 210, p.GetParserRuleContext()) == 1 { + { + p.SetState(2862) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2865) + p.Id_() + } + { + p.SetState(2866) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2867) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2868) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2870) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2871) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2872) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2874) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 211, p.GetParserRuleContext()) == 1 { + { + p.SetState(2873) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2876) + p.Id_() + } + { + p.SetState(2877) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2881) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOBJECT_TYPES { + { + p.SetState(2878) + p.Match(SnowflakeParserOBJECT_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2879) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2880) + p.Object_type_list() + } + + } + p.SetState(2884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREPLICATION_SCHEDULE { + { + p.SetState(2883) + p.Replication_schedule() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2886) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2887) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2888) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2890) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 214, p.GetParserRuleContext()) == 1 { + { + p.SetState(2889) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2892) + p.Id_() + } + { + p.SetState(2893) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2894) + p.Match(SnowflakeParserOBJECT_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2895) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2896) + p.Object_type_list() + } + p.SetState(2898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREPLICATION_SCHEDULE { + { + p.SetState(2897) + p.Replication_schedule() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2900) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2901) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2902) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2904) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 216, p.GetParserRuleContext()) == 1 { + { + p.SetState(2903) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2906) + p.Id_() + } + { + p.SetState(2907) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2908) + p.Db_name_list() + } + { + p.SetState(2909) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2910) + p.Match(SnowflakeParserALLOWED_DATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2912) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2913) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2914) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2916) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 217, p.GetParserRuleContext()) == 1 { + { + p.SetState(2915) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2918) + p.Id_() + } + { + p.SetState(2919) + p.Match(SnowflakeParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2920) + p.Match(SnowflakeParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2921) + p.Db_name_list() + } + { + p.SetState(2922) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2923) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2924) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2925) + p.Id_() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2927) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2928) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2929) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2931) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 218, p.GetParserRuleContext()) == 1 { + { + p.SetState(2930) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2933) + p.Id_() + } + { + p.SetState(2934) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2935) + p.Db_name_list() + } + { + p.SetState(2936) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2937) + p.Match(SnowflakeParserALLOWED_DATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2939) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2940) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2941) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2943) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 219, p.GetParserRuleContext()) == 1 { + { + p.SetState(2942) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2945) + p.Id_() + } + { + p.SetState(2946) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2947) + p.Share_name_list() + } + { + p.SetState(2948) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2949) + p.Match(SnowflakeParserALLOWED_SHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2951) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2952) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2953) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2955) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 220, p.GetParserRuleContext()) == 1 { + { + p.SetState(2954) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2957) + p.Id_() + } + { + p.SetState(2958) + p.Match(SnowflakeParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2959) + p.Match(SnowflakeParserSHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2960) + p.Share_name_list() + } + { + p.SetState(2961) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2962) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2963) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2964) + p.Id_() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2966) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2967) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2968) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2970) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 221, p.GetParserRuleContext()) == 1 { + { + p.SetState(2969) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2972) + p.Id_() + } + { + p.SetState(2973) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2974) + p.Share_name_list() + } + { + p.SetState(2975) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2976) + p.Match(SnowflakeParserALLOWED_SHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2978) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2979) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2980) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2982) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 222, p.GetParserRuleContext()) == 1 { + { + p.SetState(2981) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2984) + p.Id_() + } + { + p.SetState(2985) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2986) + p.Full_acct_list() + } + { + p.SetState(2987) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2988) + p.Match(SnowflakeParserALLOWED_ACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIGNORE { + { + p.SetState(2989) + p.Ignore_edition_check() + } + + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2992) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2993) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2994) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2996) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 224, p.GetParserRuleContext()) == 1 { + { + p.SetState(2995) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(2998) + p.Id_() + } + { + p.SetState(2999) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3000) + p.Full_acct_list() + } + { + p.SetState(3001) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3002) + p.Match(SnowflakeParserALLOWED_ACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3004) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3005) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3006) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3008) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 225, p.GetParserRuleContext()) == 1 { + { + p.SetState(3007) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3010) + p.Id_() + } + { + p.SetState(3011) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserPRIMARY || _la == SnowflakeParserREFRESH || _la == SnowflakeParserRESUME || _la == SnowflakeParserSUSPEND) { + 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 +} + +// IAlter_file_formatContext is an interface to support dynamic dispatch. +type IAlter_file_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SET() antlr.TerminalNode + AllFormat_type_options() []IFormat_type_optionsContext + Format_type_options(i int) IFormat_type_optionsContext + Comment_clause() IComment_clauseContext + + // IsAlter_file_formatContext differentiates from other interfaces. + IsAlter_file_formatContext() +} + +type Alter_file_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_file_formatContext() *Alter_file_formatContext { + var p = new(Alter_file_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_file_format + return p +} + +func InitEmptyAlter_file_formatContext(p *Alter_file_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_file_format +} + +func (*Alter_file_formatContext) IsAlter_file_formatContext() {} + +func NewAlter_file_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_file_formatContext { + var p = new(Alter_file_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_file_format + + return p +} + +func (s *Alter_file_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_file_formatContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_file_formatContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Alter_file_formatContext) FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT, 0) +} + +func (s *Alter_file_formatContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_file_formatContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_file_formatContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_file_formatContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_file_formatContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_file_formatContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_file_formatContext) AllFormat_type_options() []IFormat_type_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + len++ + } + } + + tst := make([]IFormat_type_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFormat_type_optionsContext); ok { + tst[i] = t.(IFormat_type_optionsContext) + i++ + } + } + + return tst +} + +func (s *Alter_file_formatContext) Format_type_options(i int) IFormat_type_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFormat_type_optionsContext) +} + +func (s *Alter_file_formatContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_file_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_file_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_file_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_file_format(s) + } +} + +func (s *Alter_file_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_file_format(s) + } +} + +func (s *Alter_file_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_file_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_file_format() (localctx IAlter_file_formatContext) { + localctx = NewAlter_file_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, SnowflakeParserRULE_alter_file_format) + var _la int + + p.SetState(3043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 231, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3015) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3016) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3017) + p.Match(SnowflakeParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3019) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 227, p.GetParserRuleContext()) == 1 { + { + p.SetState(3018) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3021) + p.Id_() + } + { + p.SetState(3022) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3023) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3024) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3026) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3027) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3028) + p.Match(SnowflakeParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3030) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 228, p.GetParserRuleContext()) == 1 { + { + p.SetState(3029) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3032) + p.Id_() + } + { + p.SetState(3033) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserALLOW_DUPLICATE || ((int64((_la-97)) & ^0x3f) == 0 && ((int64(1)<<(_la-97))&18437) != 0) || _la == SnowflakeParserCOMPRESSION || _la == SnowflakeParserDATE_FORMAT || ((int64((_la-230)) & ^0x3f) == 0 && ((int64(1)<<(_la-230))&879628696688641) != 0) || ((int64((_la-312)) & ^0x3f) == 0 && ((int64(1)<<(_la-312))&1152925902653358099) != 0) || _la == SnowflakeParserLZO || _la == SnowflakeParserNONE || _la == SnowflakeParserNULL_IF || ((int64((_la-615)) & ^0x3f) == 0 && ((int64(1)<<(_la-615))&1125917086711809) != 0) || _la == SnowflakeParserREPLACE_INVALID_CHARACTERS || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&8070450532247929043) != 0) || ((int64((_la-906)) & ^0x3f) == 0 && ((int64(1)<<(_la-906))&34359746561) != 0) || _la == SnowflakeParserZSTD { + { + p.SetState(3034) + p.Format_type_options() + } + + p.SetState(3039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(3040) + p.Comment_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 +} + +// IAlter_functionContext is an interface to support dynamic dispatch. +type IAlter_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_function_signature() IAlter_function_signatureContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + SET() antlr.TerminalNode + Comment_clause() IComment_clauseContext + SECURE() antlr.TerminalNode + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + API_INTEGRATION() antlr.TerminalNode + EQ() antlr.TerminalNode + HEADERS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + AllHeader_decl() []IHeader_declContext + Header_decl(i int) IHeader_declContext + CONTEXT_HEADERS() antlr.TerminalNode + MAX_BATCH_ROWS() antlr.TerminalNode + Num() INumContext + COMPRESSION() antlr.TerminalNode + Compression_type() ICompression_typeContext + REQUEST_TRANSLATOR() antlr.TerminalNode + RESPONSE_TRANSLATOR() antlr.TerminalNode + + // IsAlter_functionContext differentiates from other interfaces. + IsAlter_functionContext() +} + +type Alter_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_functionContext() *Alter_functionContext { + var p = new(Alter_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_function + return p +} + +func InitEmptyAlter_functionContext(p *Alter_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_function +} + +func (*Alter_functionContext) IsAlter_functionContext() {} + +func NewAlter_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_functionContext { + var p = new(Alter_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_function + + return p +} + +func (s *Alter_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_functionContext) Alter_function_signature() IAlter_function_signatureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_function_signatureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_function_signatureContext) +} + +func (s *Alter_functionContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_functionContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_functionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_functionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_functionContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_functionContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_functionContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Alter_functionContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_functionContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_functionContext) API_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_INTEGRATION, 0) +} + +func (s *Alter_functionContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Alter_functionContext) HEADERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHEADERS, 0) +} + +func (s *Alter_functionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_functionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_functionContext) AllHeader_decl() []IHeader_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHeader_declContext); ok { + len++ + } + } + + tst := make([]IHeader_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHeader_declContext); ok { + tst[i] = t.(IHeader_declContext) + i++ + } + } + + return tst +} + +func (s *Alter_functionContext) Header_decl(i int) IHeader_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHeader_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHeader_declContext) +} + +func (s *Alter_functionContext) CONTEXT_HEADERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTEXT_HEADERS, 0) +} + +func (s *Alter_functionContext) MAX_BATCH_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_BATCH_ROWS, 0) +} + +func (s *Alter_functionContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Alter_functionContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMPRESSION, 0) +} + +func (s *Alter_functionContext) Compression_type() ICompression_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompression_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompression_typeContext) +} + +func (s *Alter_functionContext) REQUEST_TRANSLATOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUEST_TRANSLATOR, 0) +} + +func (s *Alter_functionContext) RESPONSE_TRANSLATOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESPONSE_TRANSLATOR, 0) +} + +func (s *Alter_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_function(s) + } +} + +func (s *Alter_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_function(s) + } +} + +func (s *Alter_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_function() (localctx IAlter_functionContext) { + localctx = NewAlter_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, SnowflakeParserRULE_alter_function) + var _la int + + p.SetState(3116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 234, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3045) + p.Alter_function_signature() + } + { + p.SetState(3046) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3047) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3048) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3050) + p.Alter_function_signature() + } + { + p.SetState(3051) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3052) + p.Comment_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3054) + p.Alter_function_signature() + } + { + p.SetState(3055) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3056) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3058) + p.Alter_function_signature() + } + { + p.SetState(3059) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3060) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOMMENT || _la == SnowflakeParserSECURE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3062) + p.Alter_function_signature() + } + { + p.SetState(3063) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3064) + p.Match(SnowflakeParserAPI_INTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3065) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3066) + p.Id_() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3068) + p.Alter_function_signature() + } + { + p.SetState(3069) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3070) + p.Match(SnowflakeParserHEADERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3071) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3072) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserSTRING { + { + p.SetState(3073) + p.Header_decl() + } + + p.SetState(3078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3079) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3081) + p.Alter_function_signature() + } + { + p.SetState(3082) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3083) + p.Match(SnowflakeParserCONTEXT_HEADERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3084) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3085) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(3086) + p.Id_() + } + + p.SetState(3091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3092) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3094) + p.Alter_function_signature() + } + { + p.SetState(3095) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3096) + p.Match(SnowflakeParserMAX_BATCH_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3097) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3098) + p.Num() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3100) + p.Alter_function_signature() + } + { + p.SetState(3101) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3102) + p.Match(SnowflakeParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3103) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3104) + p.Compression_type() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3106) + p.Alter_function_signature() + } + { + p.SetState(3107) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3108) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserREQUEST_TRANSLATOR || _la == SnowflakeParserRESPONSE_TRANSLATOR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3109) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3110) + p.Id_() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3112) + p.Alter_function_signature() + } + { + p.SetState(3113) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3114) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-161)) & ^0x3f) == 0 && ((int64(1)<<(_la-161))&262161) != 0) || _la == SnowflakeParserHEADERS || _la == SnowflakeParserMAX_BATCH_ROWS || _la == SnowflakeParserREQUEST_TRANSLATOR || _la == SnowflakeParserRESPONSE_TRANSLATOR || _la == SnowflakeParserSECURE) { + 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 +} + +// IAlter_function_signatureContext is an interface to support dynamic dispatch. +type IAlter_function_signatureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Id_() IId_Context + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + If_exists() IIf_existsContext + Data_type_list() IData_type_listContext + + // IsAlter_function_signatureContext differentiates from other interfaces. + IsAlter_function_signatureContext() +} + +type Alter_function_signatureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_function_signatureContext() *Alter_function_signatureContext { + var p = new(Alter_function_signatureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_function_signature + return p +} + +func InitEmptyAlter_function_signatureContext(p *Alter_function_signatureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_function_signature +} + +func (*Alter_function_signatureContext) IsAlter_function_signatureContext() {} + +func NewAlter_function_signatureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_function_signatureContext { + var p = new(Alter_function_signatureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_function_signature + + return p +} + +func (s *Alter_function_signatureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_function_signatureContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_function_signatureContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Alter_function_signatureContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_function_signatureContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_function_signatureContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_function_signatureContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_function_signatureContext) Data_type_list() IData_type_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_type_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_type_listContext) +} + +func (s *Alter_function_signatureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_function_signatureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_function_signatureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_function_signature(s) + } +} + +func (s *Alter_function_signatureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_function_signature(s) + } +} + +func (s *Alter_function_signatureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_function_signature(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_function_signature() (localctx IAlter_function_signatureContext) { + localctx = NewAlter_function_signatureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, SnowflakeParserRULE_alter_function_signature) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3118) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3119) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3121) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 235, p.GetParserRuleContext()) == 1 { + { + p.SetState(3120) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3123) + p.Id_() + } + { + p.SetState(3124) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3126) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCHAR || _la == SnowflakeParserCHARACTER || _la == SnowflakeParserDOUBLE || _la == SnowflakeParserINT || _la == SnowflakeParserNUMBER || _la == SnowflakeParserOBJECT || ((int64((_la-899)) & ^0x3f) == 0 && ((int64(1)<<(_la-899))&35361) != 0) || ((int64((_la-1039)) & ^0x3f) == 0 && ((int64(1)<<(_la-1039))&267583421) != 0) { + { + p.SetState(3125) + p.Data_type_list() + } + + } + { + p.SetState(3128) + p.Match(SnowflakeParserRR_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 +} + +// IData_type_listContext is an interface to support dynamic dispatch. +type IData_type_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllData_type() []IData_typeContext + Data_type(i int) IData_typeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsData_type_listContext differentiates from other interfaces. + IsData_type_listContext() +} + +type Data_type_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyData_type_listContext() *Data_type_listContext { + var p = new(Data_type_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_data_type_list + return p +} + +func InitEmptyData_type_listContext(p *Data_type_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_data_type_list +} + +func (*Data_type_listContext) IsData_type_listContext() {} + +func NewData_type_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Data_type_listContext { + var p = new(Data_type_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_data_type_list + + return p +} + +func (s *Data_type_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Data_type_listContext) AllData_type() []IData_typeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IData_typeContext); ok { + len++ + } + } + + tst := make([]IData_typeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IData_typeContext); ok { + tst[i] = t.(IData_typeContext) + i++ + } + } + + return tst +} + +func (s *Data_type_listContext) Data_type(i int) IData_typeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Data_type_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Data_type_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Data_type_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Data_type_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Data_type_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterData_type_list(s) + } +} + +func (s *Data_type_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitData_type_list(s) + } +} + +func (s *Data_type_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitData_type_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Data_type_list() (localctx IData_type_listContext) { + localctx = NewData_type_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, SnowflakeParserRULE_data_type_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3130) + p.Data_type() + } + p.SetState(3135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(3131) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3132) + p.Data_type() + } + + p.SetState(3137) + 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_masking_policyContext is an interface to support dynamic dispatch. +type IAlter_masking_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + SET() antlr.TerminalNode + BODY() antlr.TerminalNode + ARROW() antlr.TerminalNode + Expr() IExprContext + If_exists() IIf_existsContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsAlter_masking_policyContext differentiates from other interfaces. + IsAlter_masking_policyContext() +} + +type Alter_masking_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_masking_policyContext() *Alter_masking_policyContext { + var p = new(Alter_masking_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_masking_policy + return p +} + +func InitEmptyAlter_masking_policyContext(p *Alter_masking_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_masking_policy +} + +func (*Alter_masking_policyContext) IsAlter_masking_policyContext() {} + +func NewAlter_masking_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_masking_policyContext { + var p = new(Alter_masking_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_masking_policy + + return p +} + +func (s *Alter_masking_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_masking_policyContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_masking_policyContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Alter_masking_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Alter_masking_policyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_masking_policyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_masking_policyContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_masking_policyContext) BODY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBODY, 0) +} + +func (s *Alter_masking_policyContext) ARROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARROW, 0) +} + +func (s *Alter_masking_policyContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Alter_masking_policyContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_masking_policyContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_masking_policyContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_masking_policyContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_masking_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_masking_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_masking_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_masking_policy(s) + } +} + +func (s *Alter_masking_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_masking_policy(s) + } +} + +func (s *Alter_masking_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_masking_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_masking_policy() (localctx IAlter_masking_policyContext) { + localctx = NewAlter_masking_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, SnowflakeParserRULE_alter_masking_policy) + p.SetState(3171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 241, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3138) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3139) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3140) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3142) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 238, p.GetParserRuleContext()) == 1 { + { + p.SetState(3141) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3144) + p.Id_() + } + { + p.SetState(3145) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3146) + p.Match(SnowflakeParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3147) + p.Match(SnowflakeParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3148) + p.expr(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3150) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3151) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3152) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3154) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 239, p.GetParserRuleContext()) == 1 { + { + p.SetState(3153) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3156) + p.Id_() + } + { + p.SetState(3157) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3158) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3159) + p.Id_() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3161) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3162) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3163) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3165) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 240, p.GetParserRuleContext()) == 1 { + { + p.SetState(3164) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3167) + p.Id_() + } + { + p.SetState(3168) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3169) + p.Comment_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 +} + +// IAlter_materialized_viewContext is an interface to support dynamic dispatch. +type IAlter_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + BY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expr_list() IExpr_listContext + RR_BRACKET() antlr.TerminalNode + DROP() antlr.TerminalNode + CLUSTERING() antlr.TerminalNode + KEY() antlr.TerminalNode + Resume_suspend() IResume_suspendContext + SET() antlr.TerminalNode + UNSET() antlr.TerminalNode + SECURE() antlr.TerminalNode + COMMENT() antlr.TerminalNode + RECLUSTER() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsAlter_materialized_viewContext differentiates from other interfaces. + IsAlter_materialized_viewContext() +} + +type Alter_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_materialized_viewContext() *Alter_materialized_viewContext { + var p = new(Alter_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_materialized_view + return p +} + +func InitEmptyAlter_materialized_viewContext(p *Alter_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_materialized_view +} + +func (*Alter_materialized_viewContext) IsAlter_materialized_viewContext() {} + +func NewAlter_materialized_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_materialized_viewContext { + var p = new(Alter_materialized_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_materialized_view + + return p +} + +func (s *Alter_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_materialized_viewContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATERIALIZED, 0) +} + +func (s *Alter_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Alter_materialized_viewContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_materialized_viewContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_materialized_viewContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_materialized_viewContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_materialized_viewContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTER, 0) +} + +func (s *Alter_materialized_viewContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Alter_materialized_viewContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_materialized_viewContext) 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 *Alter_materialized_viewContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_materialized_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Alter_materialized_viewContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTERING, 0) +} + +func (s *Alter_materialized_viewContext) KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEY, 0) +} + +func (s *Alter_materialized_viewContext) Resume_suspend() IResume_suspendContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResume_suspendContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResume_suspendContext) +} + +func (s *Alter_materialized_viewContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_materialized_viewContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_materialized_viewContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Alter_materialized_viewContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_materialized_viewContext) RECLUSTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECLUSTER, 0) +} + +func (s *Alter_materialized_viewContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_materialized_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_materialized_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_materialized_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_materialized_view(s) + } +} + +func (s *Alter_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_materialized_view(s) + } +} + +func (s *Alter_materialized_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_materialized_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_materialized_view() (localctx IAlter_materialized_viewContext) { + localctx = NewAlter_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, SnowflakeParserRULE_alter_materialized_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3173) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3174) + p.Match(SnowflakeParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3175) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3176) + p.Id_() + } + p.SetState(3202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserRENAME: + { + p.SetState(3177) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3178) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3179) + p.Id_() + } + + case SnowflakeParserCLUSTER: + { + p.SetState(3180) + p.Match(SnowflakeParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3181) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3182) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3183) + p.Expr_list() + } + { + p.SetState(3184) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDROP: + { + p.SetState(3186) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3187) + p.Match(SnowflakeParserCLUSTERING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3188) + p.Match(SnowflakeParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRESUME, SnowflakeParserSUSPEND: + { + p.SetState(3189) + p.Resume_suspend() + } + p.SetState(3191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserRECLUSTER { + { + p.SetState(3190) + p.Match(SnowflakeParserRECLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case SnowflakeParserSET: + { + p.SetState(3193) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURE { + { + p.SetState(3194) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(3197) + p.Comment_clause() + } + + } + + case SnowflakeParserUNSET: + { + p.SetState(3200) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3201) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOMMENT || _la == SnowflakeParserSECURE) { + 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 +} + +// IAlter_network_policyContext is an interface to support dynamic dispatch. +type IAlter_network_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + NETWORK() antlr.TerminalNode + POLICY() antlr.TerminalNode + Alter_network_policy_opts() IAlter_network_policy_optsContext + + // IsAlter_network_policyContext differentiates from other interfaces. + IsAlter_network_policyContext() +} + +type Alter_network_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_network_policyContext() *Alter_network_policyContext { + var p = new(Alter_network_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_network_policy + return p +} + +func InitEmptyAlter_network_policyContext(p *Alter_network_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_network_policy +} + +func (*Alter_network_policyContext) IsAlter_network_policyContext() {} + +func NewAlter_network_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_network_policyContext { + var p = new(Alter_network_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_network_policy + + return p +} + +func (s *Alter_network_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_network_policyContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_network_policyContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Alter_network_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Alter_network_policyContext) Alter_network_policy_opts() IAlter_network_policy_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_network_policy_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_network_policy_optsContext) +} + +func (s *Alter_network_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_network_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_network_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_network_policy(s) + } +} + +func (s *Alter_network_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_network_policy(s) + } +} + +func (s *Alter_network_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_network_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_network_policy() (localctx IAlter_network_policyContext) { + localctx = NewAlter_network_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, SnowflakeParserRULE_alter_network_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3204) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3205) + p.Match(SnowflakeParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3206) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3207) + p.Alter_network_policy_opts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_notification_integrationContext is an interface to support dynamic dispatch. +type IAlter_notification_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + SET() antlr.TerminalNode + Cloud_provider_params_auto() ICloud_provider_params_autoContext + NOTIFICATION() antlr.TerminalNode + If_exists() IIf_existsContext + Enabled_true_false() IEnabled_true_falseContext + Comment_clause() IComment_clauseContext + Cloud_provider_params_push() ICloud_provider_params_pushContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + ENABLED() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlter_notification_integrationContext differentiates from other interfaces. + IsAlter_notification_integrationContext() +} + +type Alter_notification_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_notification_integrationContext() *Alter_notification_integrationContext { + var p = new(Alter_notification_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_notification_integration + return p +} + +func InitEmptyAlter_notification_integrationContext(p *Alter_notification_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_notification_integration +} + +func (*Alter_notification_integrationContext) IsAlter_notification_integrationContext() {} + +func NewAlter_notification_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_notification_integrationContext { + var p = new(Alter_notification_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_notification_integration + + return p +} + +func (s *Alter_notification_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_notification_integrationContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_notification_integrationContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Alter_notification_integrationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_notification_integrationContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_notification_integrationContext) Cloud_provider_params_auto() ICloud_provider_params_autoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICloud_provider_params_autoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICloud_provider_params_autoContext) +} + +func (s *Alter_notification_integrationContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION, 0) +} + +func (s *Alter_notification_integrationContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_notification_integrationContext) Enabled_true_false() IEnabled_true_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnabled_true_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnabled_true_falseContext) +} + +func (s *Alter_notification_integrationContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_notification_integrationContext) Cloud_provider_params_push() ICloud_provider_params_pushContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICloud_provider_params_pushContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICloud_provider_params_pushContext) +} + +func (s *Alter_notification_integrationContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_notification_integrationContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_notification_integrationContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_notification_integrationContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Alter_notification_integrationContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_notification_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_notification_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_notification_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_notification_integration(s) + } +} + +func (s *Alter_notification_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_notification_integration(s) + } +} + +func (s *Alter_notification_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_notification_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_notification_integration() (localctx IAlter_notification_integrationContext) { + localctx = NewAlter_notification_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, SnowflakeParserRULE_alter_notification_integration) + var _la int + + p.SetState(3269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 257, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3209) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFICATION { + { + p.SetState(3210) + p.Match(SnowflakeParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3213) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3215) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 247, p.GetParserRuleContext()) == 1 { + { + p.SetState(3214) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3217) + p.Id_() + } + { + p.SetState(3218) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3220) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(3219) + p.Enabled_true_false() + } + + } + { + p.SetState(3222) + p.Cloud_provider_params_auto() + } + p.SetState(3224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(3223) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3226) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFICATION { + { + p.SetState(3227) + p.Match(SnowflakeParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3230) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3232) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 251, p.GetParserRuleContext()) == 1 { + { + p.SetState(3231) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3234) + p.Id_() + } + { + p.SetState(3235) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(3236) + p.Enabled_true_false() + } + + } + { + p.SetState(3239) + p.Cloud_provider_params_push() + } + p.SetState(3241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(3240) + p.Comment_clause() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3243) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFICATION { + { + p.SetState(3244) + p.Match(SnowflakeParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3247) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3248) + p.Id_() + } + { + p.SetState(3249) + p.Set_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3251) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFICATION { + { + p.SetState(3252) + p.Match(SnowflakeParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3255) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3256) + p.Id_() + } + { + p.SetState(3257) + p.Unset_tags() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3259) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFICATION { + { + p.SetState(3260) + p.Match(SnowflakeParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3263) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3264) + p.If_exists() + } + { + p.SetState(3265) + p.Id_() + } + { + p.SetState(3266) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3267) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOMMENT || _la == SnowflakeParserENABLED) { + 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 +} + +// IAlter_pipeContext is an interface to support dynamic dispatch. +type IAlter_pipeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + PIPE() antlr.TerminalNode + Id_() IId_Context + SET() antlr.TerminalNode + If_exists() IIf_existsContext + Object_properties() IObject_propertiesContext + Comment_clause() IComment_clauseContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + PIPE_EXECUTION_PAUSED() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + True_false() ITrue_falseContext + COMMENT() antlr.TerminalNode + REFRESH() antlr.TerminalNode + PREFIX() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + MODIFIED_AFTER() antlr.TerminalNode + + // IsAlter_pipeContext differentiates from other interfaces. + IsAlter_pipeContext() +} + +type Alter_pipeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_pipeContext() *Alter_pipeContext { + var p = new(Alter_pipeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_pipe + return p +} + +func InitEmptyAlter_pipeContext(p *Alter_pipeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_pipe +} + +func (*Alter_pipeContext) IsAlter_pipeContext() {} + +func NewAlter_pipeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_pipeContext { + var p = new(Alter_pipeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_pipe + + return p +} + +func (s *Alter_pipeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_pipeContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_pipeContext) PIPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE, 0) +} + +func (s *Alter_pipeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_pipeContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_pipeContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_pipeContext) Object_properties() IObject_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_propertiesContext) +} + +func (s *Alter_pipeContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_pipeContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_pipeContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_pipeContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_pipeContext) PIPE_EXECUTION_PAUSED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE_EXECUTION_PAUSED, 0) +} + +func (s *Alter_pipeContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_pipeContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_pipeContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_pipeContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_pipeContext) REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH, 0) +} + +func (s *Alter_pipeContext) PREFIX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREFIX, 0) +} + +func (s *Alter_pipeContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_pipeContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_pipeContext) MODIFIED_AFTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODIFIED_AFTER, 0) +} + +func (s *Alter_pipeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_pipeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_pipeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_pipe(s) + } +} + +func (s *Alter_pipeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_pipe(s) + } +} + +func (s *Alter_pipeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_pipe(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_pipe() (localctx IAlter_pipeContext) { + localctx = NewAlter_pipeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, SnowflakeParserRULE_alter_pipe) + var _la int + + p.SetState(3331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 266, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3271) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3272) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3274) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 258, p.GetParserRuleContext()) == 1 { + { + p.SetState(3273) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3276) + p.Id_() + } + { + p.SetState(3277) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3279) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 259, p.GetParserRuleContext()) == 1 { + { + p.SetState(3278) + p.Object_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(3281) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3284) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3285) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3286) + p.Id_() + } + { + p.SetState(3287) + p.Set_tags() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3289) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3290) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3291) + p.Id_() + } + { + p.SetState(3292) + p.Unset_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3294) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3295) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3297) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 261, p.GetParserRuleContext()) == 1 { + { + p.SetState(3296) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3299) + p.Id_() + } + { + p.SetState(3300) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3301) + p.Match(SnowflakeParserPIPE_EXECUTION_PAUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3302) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3303) + p.True_false() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3305) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3306) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3308) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 262, p.GetParserRuleContext()) == 1 { + { + p.SetState(3307) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3310) + p.Id_() + } + { + p.SetState(3311) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3312) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3314) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3315) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3317) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) == 1 { + { + p.SetState(3316) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3319) + p.Id_() + } + { + p.SetState(3320) + p.Match(SnowflakeParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPREFIX { + { + p.SetState(3321) + p.Match(SnowflakeParserPREFIX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3322) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3323) + p.String_() + } + + } + p.SetState(3329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMODIFIED_AFTER { + { + p.SetState(3326) + p.Match(SnowflakeParserMODIFIED_AFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3327) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3328) + p.String_() + } + + } + + 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_procedureContext is an interface to support dynamic dispatch. +type IAlter_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + Data_type_list() IData_type_listContext + SET() antlr.TerminalNode + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + AS() antlr.TerminalNode + Caller_owner() ICaller_ownerContext + + // IsAlter_procedureContext differentiates from other interfaces. + IsAlter_procedureContext() +} + +type Alter_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_procedureContext() *Alter_procedureContext { + var p = new(Alter_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_procedure + return p +} + +func InitEmptyAlter_procedureContext(p *Alter_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_procedure +} + +func (*Alter_procedureContext) IsAlter_procedureContext() {} + +func NewAlter_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_procedureContext { + var p = new(Alter_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_procedure + + return p +} + +func (s *Alter_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_procedureContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE, 0) +} + +func (s *Alter_procedureContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_procedureContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_procedureContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_procedureContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_procedureContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_procedureContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_procedureContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_procedureContext) Data_type_list() IData_type_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_type_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_type_listContext) +} + +func (s *Alter_procedureContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_procedureContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_procedureContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_procedureContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_procedureContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXECUTE, 0) +} + +func (s *Alter_procedureContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Alter_procedureContext) Caller_owner() ICaller_ownerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICaller_ownerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICaller_ownerContext) +} + +func (s *Alter_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_procedure(s) + } +} + +func (s *Alter_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_procedure(s) + } +} + +func (s *Alter_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_procedure() (localctx IAlter_procedureContext) { + localctx = NewAlter_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, SnowflakeParserRULE_alter_procedure) + var _la int + + p.SetState(3391) + 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(3333) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3334) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3336) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 267, p.GetParserRuleContext()) == 1 { + { + p.SetState(3335) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3338) + p.Id_() + } + { + p.SetState(3339) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCHAR || _la == SnowflakeParserCHARACTER || _la == SnowflakeParserDOUBLE || _la == SnowflakeParserINT || _la == SnowflakeParserNUMBER || _la == SnowflakeParserOBJECT || ((int64((_la-899)) & ^0x3f) == 0 && ((int64(1)<<(_la-899))&35361) != 0) || ((int64((_la-1039)) & ^0x3f) == 0 && ((int64(1)<<(_la-1039))&267583421) != 0) { + { + p.SetState(3340) + p.Data_type_list() + } + + } + { + p.SetState(3343) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3344) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3345) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3346) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3348) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3349) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3351) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 269, p.GetParserRuleContext()) == 1 { + { + p.SetState(3350) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3353) + p.Id_() + } + { + p.SetState(3354) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCHAR || _la == SnowflakeParserCHARACTER || _la == SnowflakeParserDOUBLE || _la == SnowflakeParserINT || _la == SnowflakeParserNUMBER || _la == SnowflakeParserOBJECT || ((int64((_la-899)) & ^0x3f) == 0 && ((int64(1)<<(_la-899))&35361) != 0) || ((int64((_la-1039)) & ^0x3f) == 0 && ((int64(1)<<(_la-1039))&267583421) != 0) { + { + p.SetState(3355) + p.Data_type_list() + } + + } + { + p.SetState(3358) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3359) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3360) + p.Comment_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3362) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3363) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3365) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 271, p.GetParserRuleContext()) == 1 { + { + p.SetState(3364) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3367) + p.Id_() + } + { + p.SetState(3368) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCHAR || _la == SnowflakeParserCHARACTER || _la == SnowflakeParserDOUBLE || _la == SnowflakeParserINT || _la == SnowflakeParserNUMBER || _la == SnowflakeParserOBJECT || ((int64((_la-899)) & ^0x3f) == 0 && ((int64(1)<<(_la-899))&35361) != 0) || ((int64((_la-1039)) & ^0x3f) == 0 && ((int64(1)<<(_la-1039))&267583421) != 0) { + { + p.SetState(3369) + p.Data_type_list() + } + + } + { + p.SetState(3372) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3373) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3374) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3376) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3377) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3379) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 273, p.GetParserRuleContext()) == 1 { + { + p.SetState(3378) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3381) + p.Id_() + } + { + p.SetState(3382) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3384) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCHAR || _la == SnowflakeParserCHARACTER || _la == SnowflakeParserDOUBLE || _la == SnowflakeParserINT || _la == SnowflakeParserNUMBER || _la == SnowflakeParserOBJECT || ((int64((_la-899)) & ^0x3f) == 0 && ((int64(1)<<(_la-899))&35361) != 0) || ((int64((_la-1039)) & ^0x3f) == 0 && ((int64(1)<<(_la-1039))&267583421) != 0) { + { + p.SetState(3383) + p.Data_type_list() + } + + } + { + p.SetState(3386) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3387) + p.Match(SnowflakeParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3388) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3389) + p.Caller_owner() + } + + 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_replication_groupContext is an interface to support dynamic dispatch. +type IAlter_replication_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AllREPLICATION() []antlr.TerminalNode + REPLICATION(i int) antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SET() antlr.TerminalNode + OBJECT_TYPES() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + Object_type_list() IObject_type_listContext + REPLICATION_SCHEDULE() antlr.TerminalNode + String_() IStringContext + ALLOWED_INTEGRATION_TYPES() antlr.TerminalNode + AllIntegration_type_name() []IIntegration_type_nameContext + Integration_type_name(i int) IIntegration_type_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ADD() antlr.TerminalNode + Db_name_list() IDb_name_listContext + ALLOWED_DATABASES() antlr.TerminalNode + MOVE() antlr.TerminalNode + DATABASES() antlr.TerminalNode + REMOVE() antlr.TerminalNode + FROM() antlr.TerminalNode + Share_name_list() IShare_name_listContext + ALLOWED_SHARES() antlr.TerminalNode + SHARES() antlr.TerminalNode + Account_id_list() IAccount_id_listContext + ALLOWED_ACCOUNTS() antlr.TerminalNode + Ignore_edition_check() IIgnore_edition_checkContext + REFRESH() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + RESUME() antlr.TerminalNode + + // IsAlter_replication_groupContext differentiates from other interfaces. + IsAlter_replication_groupContext() +} + +type Alter_replication_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_replication_groupContext() *Alter_replication_groupContext { + var p = new(Alter_replication_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_replication_group + return p +} + +func InitEmptyAlter_replication_groupContext(p *Alter_replication_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_replication_group +} + +func (*Alter_replication_groupContext) IsAlter_replication_groupContext() {} + +func NewAlter_replication_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_replication_groupContext { + var p = new(Alter_replication_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_replication_group + + return p +} + +func (s *Alter_replication_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_replication_groupContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_replication_groupContext) AllREPLICATION() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserREPLICATION) +} + +func (s *Alter_replication_groupContext) REPLICATION(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, i) +} + +func (s *Alter_replication_groupContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserGROUP) +} + +func (s *Alter_replication_groupContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, i) +} + +func (s *Alter_replication_groupContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_replication_groupContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_replication_groupContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_replication_groupContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_replication_groupContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_replication_groupContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_replication_groupContext) OBJECT_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT_TYPES, 0) +} + +func (s *Alter_replication_groupContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_replication_groupContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_replication_groupContext) Object_type_list() IObject_type_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_listContext) +} + +func (s *Alter_replication_groupContext) REPLICATION_SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION_SCHEDULE, 0) +} + +func (s *Alter_replication_groupContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_replication_groupContext) ALLOWED_INTEGRATION_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_INTEGRATION_TYPES, 0) +} + +func (s *Alter_replication_groupContext) AllIntegration_type_name() []IIntegration_type_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIntegration_type_nameContext); ok { + len++ + } + } + + tst := make([]IIntegration_type_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIntegration_type_nameContext); ok { + tst[i] = t.(IIntegration_type_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_replication_groupContext) Integration_type_name(i int) IIntegration_type_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntegration_type_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIntegration_type_nameContext) +} + +func (s *Alter_replication_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_replication_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_replication_groupContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_replication_groupContext) Db_name_list() IDb_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDb_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDb_name_listContext) +} + +func (s *Alter_replication_groupContext) ALLOWED_DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_DATABASES, 0) +} + +func (s *Alter_replication_groupContext) MOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMOVE, 0) +} + +func (s *Alter_replication_groupContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Alter_replication_groupContext) REMOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOVE, 0) +} + +func (s *Alter_replication_groupContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Alter_replication_groupContext) Share_name_list() IShare_name_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShare_name_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShare_name_listContext) +} + +func (s *Alter_replication_groupContext) ALLOWED_SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_SHARES, 0) +} + +func (s *Alter_replication_groupContext) SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARES, 0) +} + +func (s *Alter_replication_groupContext) Account_id_list() IAccount_id_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccount_id_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccount_id_listContext) +} + +func (s *Alter_replication_groupContext) ALLOWED_ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_ACCOUNTS, 0) +} + +func (s *Alter_replication_groupContext) Ignore_edition_check() IIgnore_edition_checkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIgnore_edition_checkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIgnore_edition_checkContext) +} + +func (s *Alter_replication_groupContext) REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH, 0) +} + +func (s *Alter_replication_groupContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND, 0) +} + +func (s *Alter_replication_groupContext) RESUME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESUME, 0) +} + +func (s *Alter_replication_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_replication_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_replication_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_replication_group(s) + } +} + +func (s *Alter_replication_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_replication_group(s) + } +} + +func (s *Alter_replication_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_replication_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_replication_group() (localctx IAlter_replication_groupContext) { + localctx = NewAlter_replication_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, SnowflakeParserRULE_alter_replication_group) + var _la int + + p.SetState(3579) + 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(3393) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3394) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3395) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3397) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 276, p.GetParserRuleContext()) == 1 { + { + p.SetState(3396) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3399) + p.Id_() + } + { + p.SetState(3400) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3401) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3402) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3404) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3405) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3406) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3408) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 277, p.GetParserRuleContext()) == 1 { + { + p.SetState(3407) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3410) + p.Id_() + } + { + p.SetState(3411) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOBJECT_TYPES { + { + p.SetState(3412) + p.Match(SnowflakeParserOBJECT_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3413) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3414) + p.Object_type_list() + } + + } + p.SetState(3420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREPLICATION_SCHEDULE { + { + p.SetState(3417) + p.Match(SnowflakeParserREPLICATION_SCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3418) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3419) + p.String_() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3422) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3423) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3424) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3426) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 280, p.GetParserRuleContext()) == 1 { + { + p.SetState(3425) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3428) + p.Id_() + } + { + p.SetState(3429) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3430) + p.Match(SnowflakeParserOBJECT_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3431) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3432) + p.Object_type_list() + } + { + p.SetState(3433) + p.Match(SnowflakeParserALLOWED_INTEGRATION_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3434) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3435) + p.Integration_type_name() + } + p.SetState(3440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(3436) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3437) + p.Integration_type_name() + } + + p.SetState(3442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREPLICATION_SCHEDULE { + { + p.SetState(3443) + p.Match(SnowflakeParserREPLICATION_SCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3444) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3445) + p.String_() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3448) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3449) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3450) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3452) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 283, p.GetParserRuleContext()) == 1 { + { + p.SetState(3451) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3454) + p.Id_() + } + { + p.SetState(3455) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3456) + p.Db_name_list() + } + { + p.SetState(3457) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3458) + p.Match(SnowflakeParserALLOWED_DATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3460) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3461) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3462) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3464) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 284, p.GetParserRuleContext()) == 1 { + { + p.SetState(3463) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3466) + p.Id_() + } + { + p.SetState(3467) + p.Match(SnowflakeParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3468) + p.Match(SnowflakeParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3469) + p.Db_name_list() + } + { + p.SetState(3470) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3471) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3472) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3473) + p.Id_() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3475) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3476) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3477) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3479) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 285, p.GetParserRuleContext()) == 1 { + { + p.SetState(3478) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3481) + p.Id_() + } + { + p.SetState(3482) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3483) + p.Db_name_list() + } + { + p.SetState(3484) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3485) + p.Match(SnowflakeParserALLOWED_DATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3487) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3488) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3489) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3491) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 286, p.GetParserRuleContext()) == 1 { + { + p.SetState(3490) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3493) + p.Id_() + } + { + p.SetState(3494) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3495) + p.Share_name_list() + } + { + p.SetState(3496) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3497) + p.Match(SnowflakeParserALLOWED_SHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3499) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3500) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3501) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3503) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 287, p.GetParserRuleContext()) == 1 { + { + p.SetState(3502) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3505) + p.Id_() + } + { + p.SetState(3506) + p.Match(SnowflakeParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3507) + p.Match(SnowflakeParserSHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3508) + p.Share_name_list() + } + { + p.SetState(3509) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3510) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3511) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3512) + p.Id_() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3514) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3515) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3516) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3518) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 288, p.GetParserRuleContext()) == 1 { + { + p.SetState(3517) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3520) + p.Id_() + } + { + p.SetState(3521) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3522) + p.Share_name_list() + } + { + p.SetState(3523) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3524) + p.Match(SnowflakeParserALLOWED_SHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(3526) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3527) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3528) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3530) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 289, p.GetParserRuleContext()) == 1 { + { + p.SetState(3529) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3532) + p.Id_() + } + { + p.SetState(3533) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3534) + p.Account_id_list() + } + { + p.SetState(3535) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3536) + p.Match(SnowflakeParserALLOWED_ACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIGNORE { + { + p.SetState(3537) + p.Ignore_edition_check() + } + + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(3540) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3541) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3542) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3544) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 291, p.GetParserRuleContext()) == 1 { + { + p.SetState(3543) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3546) + p.Id_() + } + { + p.SetState(3547) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3548) + p.Account_id_list() + } + { + p.SetState(3549) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3550) + p.Match(SnowflakeParserALLOWED_ACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(3552) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3553) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3554) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3556) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 292, p.GetParserRuleContext()) == 1 { + { + p.SetState(3555) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3558) + p.Id_() + } + { + p.SetState(3559) + p.Match(SnowflakeParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(3561) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3562) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3563) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3565) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 293, p.GetParserRuleContext()) == 1 { + { + p.SetState(3564) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3567) + p.Id_() + } + { + p.SetState(3568) + p.Match(SnowflakeParserSUSPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(3570) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3571) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3572) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3574) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 294, p.GetParserRuleContext()) == 1 { + { + p.SetState(3573) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3576) + p.Id_() + } + { + p.SetState(3577) + p.Match(SnowflakeParserRESUME) + 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 +} + +// ICredit_quotaContext is an interface to support dynamic dispatch. +type ICredit_quotaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREDIT_QUOTA() antlr.TerminalNode + EQ() antlr.TerminalNode + Num() INumContext + + // IsCredit_quotaContext differentiates from other interfaces. + IsCredit_quotaContext() +} + +type Credit_quotaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCredit_quotaContext() *Credit_quotaContext { + var p = new(Credit_quotaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_credit_quota + return p +} + +func InitEmptyCredit_quotaContext(p *Credit_quotaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_credit_quota +} + +func (*Credit_quotaContext) IsCredit_quotaContext() {} + +func NewCredit_quotaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Credit_quotaContext { + var p = new(Credit_quotaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_credit_quota + + return p +} + +func (s *Credit_quotaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Credit_quotaContext) CREDIT_QUOTA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREDIT_QUOTA, 0) +} + +func (s *Credit_quotaContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Credit_quotaContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Credit_quotaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Credit_quotaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Credit_quotaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCredit_quota(s) + } +} + +func (s *Credit_quotaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCredit_quota(s) + } +} + +func (s *Credit_quotaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCredit_quota(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Credit_quota() (localctx ICredit_quotaContext) { + localctx = NewCredit_quotaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, SnowflakeParserRULE_credit_quota) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3581) + p.Match(SnowflakeParserCREDIT_QUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3582) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3583) + p.Num() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFrequencyContext is an interface to support dynamic dispatch. +type IFrequencyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FREQUENCY() antlr.TerminalNode + EQ() antlr.TerminalNode + MONTHLY() antlr.TerminalNode + DAILY() antlr.TerminalNode + WEEKLY() antlr.TerminalNode + YEARLY() antlr.TerminalNode + NEVER() antlr.TerminalNode + + // IsFrequencyContext differentiates from other interfaces. + IsFrequencyContext() +} + +type FrequencyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrequencyContext() *FrequencyContext { + var p = new(FrequencyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_frequency + return p +} + +func InitEmptyFrequencyContext(p *FrequencyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_frequency +} + +func (*FrequencyContext) IsFrequencyContext() {} + +func NewFrequencyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FrequencyContext { + var p = new(FrequencyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_frequency + + return p +} + +func (s *FrequencyContext) GetParser() antlr.Parser { return s.parser } + +func (s *FrequencyContext) FREQUENCY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFREQUENCY, 0) +} + +func (s *FrequencyContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *FrequencyContext) MONTHLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONTHLY, 0) +} + +func (s *FrequencyContext) DAILY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDAILY, 0) +} + +func (s *FrequencyContext) WEEKLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWEEKLY, 0) +} + +func (s *FrequencyContext) YEARLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserYEARLY, 0) +} + +func (s *FrequencyContext) NEVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEVER, 0) +} + +func (s *FrequencyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FrequencyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FrequencyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFrequency(s) + } +} + +func (s *FrequencyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFrequency(s) + } +} + +func (s *FrequencyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFrequency(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Frequency() (localctx IFrequencyContext) { + localctx = NewFrequencyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, SnowflakeParserRULE_frequency) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3585) + p.Match(SnowflakeParserFREQUENCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3586) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3587) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDAILY || _la == SnowflakeParserMONTHLY || _la == SnowflakeParserNEVER || _la == SnowflakeParserWEEKLY || _la == SnowflakeParserYEARLY) { + 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 +} + +// INotify_usersContext is an interface to support dynamic dispatch. +type INotify_usersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOTIFY_USERS() antlr.TerminalNode + EQ() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsNotify_usersContext differentiates from other interfaces. + IsNotify_usersContext() +} + +type Notify_usersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNotify_usersContext() *Notify_usersContext { + var p = new(Notify_usersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_notify_users + return p +} + +func InitEmptyNotify_usersContext(p *Notify_usersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_notify_users +} + +func (*Notify_usersContext) IsNotify_usersContext() {} + +func NewNotify_usersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Notify_usersContext { + var p = new(Notify_usersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_notify_users + + return p +} + +func (s *Notify_usersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Notify_usersContext) NOTIFY_USERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFY_USERS, 0) +} + +func (s *Notify_usersContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Notify_usersContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Notify_usersContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Notify_usersContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Notify_usersContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Notify_usersContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Notify_usersContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Notify_usersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Notify_usersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Notify_usersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterNotify_users(s) + } +} + +func (s *Notify_usersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitNotify_users(s) + } +} + +func (s *Notify_usersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitNotify_users(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Notify_users() (localctx INotify_usersContext) { + localctx = NewNotify_usersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, SnowflakeParserRULE_notify_users) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3589) + p.Match(SnowflakeParserNOTIFY_USERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3590) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3591) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3592) + p.Id_() + } + p.SetState(3597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(3593) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3594) + p.Id_() + } + + p.SetState(3599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3600) + p.Match(SnowflakeParserRR_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 +} + +// ITriggerDefinitionContext is an interface to support dynamic dispatch. +type ITriggerDefinitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Num() INumContext + PERCENT() antlr.TerminalNode + DO() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + SUSPEND_IMMEDIATE() antlr.TerminalNode + NOTIFY() antlr.TerminalNode + + // IsTriggerDefinitionContext differentiates from other interfaces. + IsTriggerDefinitionContext() +} + +type TriggerDefinitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTriggerDefinitionContext() *TriggerDefinitionContext { + var p = new(TriggerDefinitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_triggerDefinition + return p +} + +func InitEmptyTriggerDefinitionContext(p *TriggerDefinitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_triggerDefinition +} + +func (*TriggerDefinitionContext) IsTriggerDefinitionContext() {} + +func NewTriggerDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TriggerDefinitionContext { + var p = new(TriggerDefinitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_triggerDefinition + + return p +} + +func (s *TriggerDefinitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *TriggerDefinitionContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *TriggerDefinitionContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *TriggerDefinitionContext) PERCENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERCENT, 0) +} + +func (s *TriggerDefinitionContext) DO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDO, 0) +} + +func (s *TriggerDefinitionContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND, 0) +} + +func (s *TriggerDefinitionContext) SUSPEND_IMMEDIATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND_IMMEDIATE, 0) +} + +func (s *TriggerDefinitionContext) NOTIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFY, 0) +} + +func (s *TriggerDefinitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TriggerDefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TriggerDefinitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTriggerDefinition(s) + } +} + +func (s *TriggerDefinitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTriggerDefinition(s) + } +} + +func (s *TriggerDefinitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTriggerDefinition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) TriggerDefinition() (localctx ITriggerDefinitionContext) { + localctx = NewTriggerDefinitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, SnowflakeParserRULE_triggerDefinition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3602) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3603) + p.Num() + } + { + p.SetState(3604) + p.Match(SnowflakeParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3605) + p.Match(SnowflakeParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3606) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserNOTIFY || _la == SnowflakeParserSUSPEND || _la == SnowflakeParserSUSPEND_IMMEDIATE) { + 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 +} + +// IAlter_resource_monitorContext is an interface to support dynamic dispatch. +type IAlter_resource_monitorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + MONITOR() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + SET() antlr.TerminalNode + Notify_users() INotify_usersContext + Credit_quota() ICredit_quotaContext + Frequency() IFrequencyContext + START_TIMESTAMP() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + IMMEDIATELY() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + END_TIMESTAMP() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + AllTriggerDefinition() []ITriggerDefinitionContext + TriggerDefinition(i int) ITriggerDefinitionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_resource_monitorContext differentiates from other interfaces. + IsAlter_resource_monitorContext() +} + +type Alter_resource_monitorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_resource_monitorContext() *Alter_resource_monitorContext { + var p = new(Alter_resource_monitorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_resource_monitor + return p +} + +func InitEmptyAlter_resource_monitorContext(p *Alter_resource_monitorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_resource_monitor +} + +func (*Alter_resource_monitorContext) IsAlter_resource_monitorContext() {} + +func NewAlter_resource_monitorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_resource_monitorContext { + var p = new(Alter_resource_monitorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_resource_monitor + + return p +} + +func (s *Alter_resource_monitorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_resource_monitorContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_resource_monitorContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE, 0) +} + +func (s *Alter_resource_monitorContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Alter_resource_monitorContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_resource_monitorContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_resource_monitorContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_resource_monitorContext) Notify_users() INotify_usersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INotify_usersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INotify_usersContext) +} + +func (s *Alter_resource_monitorContext) Credit_quota() ICredit_quotaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICredit_quotaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICredit_quotaContext) +} + +func (s *Alter_resource_monitorContext) Frequency() IFrequencyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrequencyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrequencyContext) +} + +func (s *Alter_resource_monitorContext) START_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTART_TIMESTAMP, 0) +} + +func (s *Alter_resource_monitorContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_resource_monitorContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_resource_monitorContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_resource_monitorContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_resource_monitorContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_resource_monitorContext) IMMEDIATELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMEDIATELY, 0) +} + +func (s *Alter_resource_monitorContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_resource_monitorContext) END_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEND_TIMESTAMP, 0) +} + +func (s *Alter_resource_monitorContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRIGGERS, 0) +} + +func (s *Alter_resource_monitorContext) AllTriggerDefinition() []ITriggerDefinitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITriggerDefinitionContext); ok { + len++ + } + } + + tst := make([]ITriggerDefinitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITriggerDefinitionContext); ok { + tst[i] = t.(ITriggerDefinitionContext) + i++ + } + } + + return tst +} + +func (s *Alter_resource_monitorContext) TriggerDefinition(i int) ITriggerDefinitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITriggerDefinitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITriggerDefinitionContext) +} + +func (s *Alter_resource_monitorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_resource_monitorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_resource_monitorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_resource_monitorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_resource_monitorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_resource_monitor(s) + } +} + +func (s *Alter_resource_monitorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_resource_monitor(s) + } +} + +func (s *Alter_resource_monitorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_resource_monitor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_resource_monitor() (localctx IAlter_resource_monitorContext) { + localctx = NewAlter_resource_monitorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, SnowflakeParserRULE_alter_resource_monitor) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3608) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3609) + p.Match(SnowflakeParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3610) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3612) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 297, p.GetParserRuleContext()) == 1 { + { + p.SetState(3611) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3614) + p.Id_() + } + p.SetState(3635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET { + { + p.SetState(3615) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3617) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCREDIT_QUOTA { + { + p.SetState(3616) + p.Credit_quota() + } + + } + p.SetState(3620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFREQUENCY { + { + p.SetState(3619) + p.Frequency() + } + + } + p.SetState(3628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTART_TIMESTAMP: + { + p.SetState(3622) + p.Match(SnowflakeParserSTART_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3623) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3624) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3625) + p.String_() + } + + case SnowflakeParserIMMEDIATELY: + { + p.SetState(3626) + p.Match(SnowflakeParserIMMEDIATELY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3627) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserEOF, SnowflakeParserEND_TIMESTAMP, SnowflakeParserNOTIFY_USERS, SnowflakeParserSEMI: + + default: + } + p.SetState(3633) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEND_TIMESTAMP { + { + p.SetState(3630) + p.Match(SnowflakeParserEND_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3631) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3632) + p.String_() + } + + } + + } + p.SetState(3649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFY_USERS { + { + p.SetState(3637) + p.Notify_users() + } + p.SetState(3647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTRIGGERS { + { + p.SetState(3638) + p.Match(SnowflakeParserTRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3639) + p.TriggerDefinition() + } + p.SetState(3644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(3640) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3641) + p.TriggerDefinition() + } + + p.SetState(3646) + 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_roleContext is an interface to support dynamic dispatch. +type IAlter_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SET() antlr.TerminalNode + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + + // IsAlter_roleContext differentiates from other interfaces. + IsAlter_roleContext() +} + +type Alter_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_roleContext() *Alter_roleContext { + var p = new(Alter_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_role + return p +} + +func InitEmptyAlter_roleContext(p *Alter_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_role +} + +func (*Alter_roleContext) IsAlter_roleContext() {} + +func NewAlter_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_roleContext { + var p = new(Alter_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_role + + return p +} + +func (s *Alter_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_roleContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Alter_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_roleContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_roleContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_roleContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_roleContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_roleContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_roleContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_roleContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_roleContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_roleContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_role(s) + } +} + +func (s *Alter_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_role(s) + } +} + +func (s *Alter_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_role() (localctx IAlter_roleContext) { + localctx = NewAlter_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, SnowflakeParserRULE_alter_role) + p.SetState(3695) + 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(3651) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3652) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3654) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 306, p.GetParserRuleContext()) == 1 { + { + p.SetState(3653) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3656) + p.Id_() + } + { + p.SetState(3657) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3658) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3659) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3661) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3662) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3664) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 307, p.GetParserRuleContext()) == 1 { + { + p.SetState(3663) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3666) + p.Id_() + } + { + p.SetState(3667) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3668) + p.Comment_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3670) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3671) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3673) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 308, p.GetParserRuleContext()) == 1 { + { + p.SetState(3672) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3675) + p.Id_() + } + { + p.SetState(3676) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3677) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3679) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3680) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3682) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 309, p.GetParserRuleContext()) == 1 { + { + p.SetState(3681) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3684) + p.Id_() + } + { + p.SetState(3685) + p.Set_tags() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3687) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3688) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 310, p.GetParserRuleContext()) == 1 { + { + p.SetState(3689) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3692) + p.Id_() + } + { + p.SetState(3693) + p.Unset_tags() + } + + 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_row_access_policyContext is an interface to support dynamic dispatch. +type IAlter_row_access_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + POLICY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + SET() antlr.TerminalNode + BODY() antlr.TerminalNode + ARROW() antlr.TerminalNode + Expr() IExprContext + If_exists() IIf_existsContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsAlter_row_access_policyContext differentiates from other interfaces. + IsAlter_row_access_policyContext() +} + +type Alter_row_access_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_row_access_policyContext() *Alter_row_access_policyContext { + var p = new(Alter_row_access_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_row_access_policy + return p +} + +func InitEmptyAlter_row_access_policyContext(p *Alter_row_access_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_row_access_policy +} + +func (*Alter_row_access_policyContext) IsAlter_row_access_policyContext() {} + +func NewAlter_row_access_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_row_access_policyContext { + var p = new(Alter_row_access_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_row_access_policy + + return p +} + +func (s *Alter_row_access_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_row_access_policyContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_row_access_policyContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Alter_row_access_policyContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Alter_row_access_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Alter_row_access_policyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_row_access_policyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_row_access_policyContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_row_access_policyContext) BODY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBODY, 0) +} + +func (s *Alter_row_access_policyContext) ARROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARROW, 0) +} + +func (s *Alter_row_access_policyContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Alter_row_access_policyContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_row_access_policyContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_row_access_policyContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_row_access_policyContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_row_access_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_row_access_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_row_access_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_row_access_policy(s) + } +} + +func (s *Alter_row_access_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_row_access_policy(s) + } +} + +func (s *Alter_row_access_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_row_access_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_row_access_policy() (localctx IAlter_row_access_policyContext) { + localctx = NewAlter_row_access_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, SnowflakeParserRULE_alter_row_access_policy) + p.SetState(3733) + 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(3697) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3698) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3699) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3700) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3702) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 312, p.GetParserRuleContext()) == 1 { + { + p.SetState(3701) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3704) + p.Id_() + } + { + p.SetState(3705) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3706) + p.Match(SnowflakeParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3707) + p.Match(SnowflakeParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3708) + p.expr(0) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3710) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3711) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3712) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3713) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3715) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 313, p.GetParserRuleContext()) == 1 { + { + p.SetState(3714) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3717) + p.Id_() + } + { + p.SetState(3718) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3719) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3720) + p.Id_() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3722) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3723) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3724) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3725) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3727) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 314, p.GetParserRuleContext()) == 1 { + { + p.SetState(3726) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3729) + p.Id_() + } + { + p.SetState(3730) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3731) + p.Comment_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 +} + +// IAlter_schemaContext is an interface to support dynamic dispatch. +type IAlter_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SWAP() antlr.TerminalNode + WITH() antlr.TerminalNode + SET() antlr.TerminalNode + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + Default_ddl_collation() IDefault_ddl_collationContext + Comment_clause() IComment_clauseContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + AllSchema_property() []ISchema_propertyContext + Schema_property(i int) ISchema_propertyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + MANAGED() antlr.TerminalNode + ACCESS() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsAlter_schemaContext differentiates from other interfaces. + IsAlter_schemaContext() +} + +type Alter_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_schemaContext() *Alter_schemaContext { + var p = new(Alter_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_schema + return p +} + +func InitEmptyAlter_schemaContext(p *Alter_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_schema +} + +func (*Alter_schemaContext) IsAlter_schemaContext() {} + +func NewAlter_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_schemaContext { + var p = new(Alter_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_schema + + return p +} + +func (s *Alter_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_schemaContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_schemaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Alter_schemaContext) AllSchema_name() []ISchema_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_nameContext); ok { + len++ + } + } + + tst := make([]ISchema_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_nameContext); ok { + tst[i] = t.(ISchema_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_schemaContext) Schema_name(i int) ISchema_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Alter_schemaContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_schemaContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_schemaContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_schemaContext) SWAP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSWAP, 0) +} + +func (s *Alter_schemaContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Alter_schemaContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_schemaContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Alter_schemaContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_schemaContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_schemaContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Alter_schemaContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Alter_schemaContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Alter_schemaContext) Default_ddl_collation() IDefault_ddl_collationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_ddl_collationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_ddl_collationContext) +} + +func (s *Alter_schemaContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_schemaContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_schemaContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_schemaContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_schemaContext) AllSchema_property() []ISchema_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISchema_propertyContext); ok { + len++ + } + } + + tst := make([]ISchema_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISchema_propertyContext); ok { + tst[i] = t.(ISchema_propertyContext) + i++ + } + } + + return tst +} + +func (s *Alter_schemaContext) Schema_property(i int) ISchema_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISchema_propertyContext) +} + +func (s *Alter_schemaContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_schemaContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_schemaContext) MANAGED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMANAGED, 0) +} + +func (s *Alter_schemaContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Alter_schemaContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *Alter_schemaContext) DISABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE, 0) +} + +func (s *Alter_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_schema(s) + } +} + +func (s *Alter_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_schema(s) + } +} + +func (s *Alter_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_schema() (localctx IAlter_schemaContext) { + localctx = NewAlter_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, SnowflakeParserRULE_alter_schema) + var _la int + + p.SetState(3819) + 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(3735) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3736) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3738) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 316, p.GetParserRuleContext()) == 1 { + { + p.SetState(3737) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3740) + p.Schema_name() + } + { + p.SetState(3741) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3742) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3743) + p.Schema_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3745) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3746) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3748) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 317, p.GetParserRuleContext()) == 1 { + { + p.SetState(3747) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3750) + p.Schema_name() + } + { + p.SetState(3751) + p.Match(SnowflakeParserSWAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3752) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3753) + p.Schema_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3755) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3756) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3758) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 318, p.GetParserRuleContext()) == 1 { + { + p.SetState(3757) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3760) + p.Schema_name() + } + { + p.SetState(3761) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDATA_RETENTION_TIME_IN_DAYS { + { + p.SetState(3762) + p.Match(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3763) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3764) + p.Num() + } + + } + p.SetState(3770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS { + { + p.SetState(3767) + p.Match(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3768) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3769) + p.Num() + } + + } + p.SetState(3773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDEFAULT_DDL_COLLATION_ { + { + p.SetState(3772) + p.Default_ddl_collation() + } + + } + p.SetState(3776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(3775) + p.Comment_clause() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3778) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3779) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3781) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 323, p.GetParserRuleContext()) == 1 { + { + p.SetState(3780) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3783) + p.Schema_name() + } + { + p.SetState(3784) + p.Set_tags() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3786) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3787) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3789) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext()) == 1 { + { + p.SetState(3788) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3791) + p.Schema_name() + } + { + p.SetState(3792) + p.Unset_tags() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3794) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3795) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3797) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 325, p.GetParserRuleContext()) == 1 { + { + p.SetState(3796) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3799) + p.Schema_name() + } + { + p.SetState(3800) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3801) + p.Schema_property() + } + p.SetState(3806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(3802) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3803) + p.Schema_property() + } + + p.SetState(3808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3809) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3810) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3812) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 327, p.GetParserRuleContext()) == 1 { + { + p.SetState(3811) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3814) + p.Schema_name() + } + { + p.SetState(3815) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDISABLE || _la == SnowflakeParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3816) + p.Match(SnowflakeParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3817) + p.Match(SnowflakeParserACCESS) + 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 +} + +// ISchema_propertyContext is an interface to support dynamic dispatch. +type ISchema_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + DEFAULT_DDL_COLLATION_() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsSchema_propertyContext differentiates from other interfaces. + IsSchema_propertyContext() +} + +type Schema_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_propertyContext() *Schema_propertyContext { + var p = new(Schema_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_property + return p +} + +func InitEmptySchema_propertyContext(p *Schema_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_property +} + +func (*Schema_propertyContext) IsSchema_propertyContext() {} + +func NewSchema_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_propertyContext { + var p = new(Schema_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_schema_property + + return p +} + +func (s *Schema_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_propertyContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Schema_propertyContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Schema_propertyContext) DEFAULT_DDL_COLLATION_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_DDL_COLLATION_, 0) +} + +func (s *Schema_propertyContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Schema_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSchema_property(s) + } +} + +func (s *Schema_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSchema_property(s) + } +} + +func (s *Schema_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSchema_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Schema_property() (localctx ISchema_propertyContext) { + localctx = NewSchema_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, SnowflakeParserRULE_schema_property) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3821) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-161)) & ^0x3f) == 0 && ((int64(1)<<(_la-161))&2306124484190404609) != 0) || _la == SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) { + 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 +} + +// IAlter_security_integrationContext is an interface to support dynamic dispatch. +type IAlter_security_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + AllObject_name() []IObject_nameContext + Object_name(i int) IObject_nameContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SET() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + Num() INumContext + BY() antlr.TerminalNode + EQ() antlr.TerminalNode + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlter_security_integrationContext differentiates from other interfaces. + IsAlter_security_integrationContext() +} + +type Alter_security_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_security_integrationContext() *Alter_security_integrationContext { + var p = new(Alter_security_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration + return p +} + +func InitEmptyAlter_security_integrationContext(p *Alter_security_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration +} + +func (*Alter_security_integrationContext) IsAlter_security_integrationContext() {} + +func NewAlter_security_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_security_integrationContext { + var p = new(Alter_security_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_security_integration + + return p +} + +func (s *Alter_security_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_security_integrationContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_security_integrationContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 0) +} + +func (s *Alter_security_integrationContext) AllObject_name() []IObject_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_nameContext); ok { + len++ + } + } + + tst := make([]IObject_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_nameContext); ok { + tst[i] = t.(IObject_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integrationContext) Object_name(i int) IObject_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Alter_security_integrationContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_security_integrationContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_security_integrationContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_security_integrationContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_security_integrationContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINCREMENT, 0) +} + +func (s *Alter_security_integrationContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Alter_security_integrationContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Alter_security_integrationContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Alter_security_integrationContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_security_integrationContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_security_integrationContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_security_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_security_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_security_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_security_integration(s) + } +} + +func (s *Alter_security_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_security_integration(s) + } +} + +func (s *Alter_security_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_security_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_security_integration() (localctx IAlter_security_integrationContext) { + localctx = NewAlter_security_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, SnowflakeParserRULE_alter_security_integration) + var _la int + + p.SetState(3870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 337, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3823) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3824) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3826) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 329, p.GetParserRuleContext()) == 1 { + { + p.SetState(3825) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3828) + p.Object_name() + } + { + p.SetState(3829) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3830) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3831) + p.Object_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3833) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3834) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3836) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 330, p.GetParserRuleContext()) == 1 { + { + p.SetState(3835) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3838) + p.Object_name() + } + p.SetState(3840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET { + { + p.SetState(3839) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserINCREMENT { + { + p.SetState(3842) + p.Match(SnowflakeParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserBY { + { + p.SetState(3843) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEQ { + { + p.SetState(3846) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3849) + p.Num() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3852) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3853) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3855) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 335, p.GetParserRuleContext()) == 1 { + { + p.SetState(3854) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3857) + p.Object_name() + } + { + p.SetState(3858) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3859) + p.Comment_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3861) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3862) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3864) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 336, p.GetParserRuleContext()) == 1 { + { + p.SetState(3863) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3866) + p.Object_name() + } + { + p.SetState(3867) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3868) + p.Match(SnowflakeParserCOMMENT) + 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 +} + +// IAlter_security_integration_external_oauthContext is an interface to support dynamic dispatch. +type IAlter_security_integration_external_oauthContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + If_exists() IIf_existsContext + Id_() IId_Context + SET() antlr.TerminalNode + SECURITY() antlr.TerminalNode + TYPE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + EXTERNAL_OAUTH() antlr.TerminalNode + ENABLED() antlr.TerminalNode + True_false() ITrue_falseContext + EXTERNAL_OAUTH_TYPE() antlr.TerminalNode + EXTERNAL_OAUTH_ISSUER() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM() antlr.TerminalNode + EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE() antlr.TerminalNode + AllEXTERNAL_OAUTH_JWS_KEYS_URL() []antlr.TerminalNode + EXTERNAL_OAUTH_JWS_KEYS_URL(i int) antlr.TerminalNode + EXTERNAL_OAUTH_RSA_PUBLIC_KEY() antlr.TerminalNode + EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2() antlr.TerminalNode + EXTERNAL_OAUTH_BLOCKED_ROLES_LIST() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllString_list() []IString_listContext + String_list(i int) IString_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + EXTERNAL_OAUTH_ALLOWED_ROLES_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode + AllEXTERNAL_OAUTH_ANY_ROLE_MODE() []antlr.TerminalNode + EXTERNAL_OAUTH_ANY_ROLE_MODE(i int) antlr.TerminalNode + OKTA() antlr.TerminalNode + AZURE() antlr.TerminalNode + PING_FEDERATE() antlr.TerminalNode + CUSTOM() antlr.TerminalNode + DISABLE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENABLE_FOR_PRIVILEGE() antlr.TerminalNode + UNSET() antlr.TerminalNode + AllSecurity_integration_external_oauth_property() []ISecurity_integration_external_oauth_propertyContext + Security_integration_external_oauth_property(i int) ISecurity_integration_external_oauth_propertyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + + // IsAlter_security_integration_external_oauthContext differentiates from other interfaces. + IsAlter_security_integration_external_oauthContext() +} + +type Alter_security_integration_external_oauthContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_security_integration_external_oauthContext() *Alter_security_integration_external_oauthContext { + var p = new(Alter_security_integration_external_oauthContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_external_oauth + return p +} + +func InitEmptyAlter_security_integration_external_oauthContext(p *Alter_security_integration_external_oauthContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_external_oauth +} + +func (*Alter_security_integration_external_oauthContext) IsAlter_security_integration_external_oauthContext() { +} + +func NewAlter_security_integration_external_oauthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_security_integration_external_oauthContext { + var p = new(Alter_security_integration_external_oauthContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_external_oauth + + return p +} + +func (s *Alter_security_integration_external_oauthContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_security_integration_external_oauthContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_security_integration_external_oauthContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Alter_security_integration_external_oauthContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_security_integration_external_oauthContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_security_integration_external_oauthContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_security_integration_external_oauthContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Alter_security_integration_external_oauthContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Alter_security_integration_external_oauthContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_security_integration_external_oauthContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH, 0) +} + +func (s *Alter_security_integration_external_oauthContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Alter_security_integration_external_oauthContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_TYPE, 0) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_ISSUER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ISSUER, 0) +} + +func (s *Alter_security_integration_external_oauthContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_external_oauthContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, 0) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, 0) +} + +func (s *Alter_security_integration_external_oauthContext) AllEXTERNAL_OAUTH_JWS_KEYS_URL() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_JWS_KEYS_URL(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, i) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, 0) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2, 0) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_BLOCKED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, 0) +} + +func (s *Alter_security_integration_external_oauthContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Alter_security_integration_external_oauthContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Alter_security_integration_external_oauthContext) AllString_list() []IString_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_listContext); ok { + len++ + } + } + + tst := make([]IString_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_listContext); ok { + tst[i] = t.(IString_listContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_external_oauthContext) String_list(i int) IString_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Alter_security_integration_external_oauthContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Alter_security_integration_external_oauthContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_ALLOWED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, 0) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, 0) +} + +func (s *Alter_security_integration_external_oauthContext) AllEXTERNAL_OAUTH_ANY_ROLE_MODE() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE) +} + +func (s *Alter_security_integration_external_oauthContext) EXTERNAL_OAUTH_ANY_ROLE_MODE(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, i) +} + +func (s *Alter_security_integration_external_oauthContext) OKTA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOKTA, 0) +} + +func (s *Alter_security_integration_external_oauthContext) AZURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE, 0) +} + +func (s *Alter_security_integration_external_oauthContext) PING_FEDERATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPING_FEDERATE, 0) +} + +func (s *Alter_security_integration_external_oauthContext) CUSTOM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCUSTOM, 0) +} + +func (s *Alter_security_integration_external_oauthContext) DISABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE, 0) +} + +func (s *Alter_security_integration_external_oauthContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *Alter_security_integration_external_oauthContext) ENABLE_FOR_PRIVILEGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_FOR_PRIVILEGE, 0) +} + +func (s *Alter_security_integration_external_oauthContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_security_integration_external_oauthContext) AllSecurity_integration_external_oauth_property() []ISecurity_integration_external_oauth_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISecurity_integration_external_oauth_propertyContext); ok { + len++ + } + } + + tst := make([]ISecurity_integration_external_oauth_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISecurity_integration_external_oauth_propertyContext); ok { + tst[i] = t.(ISecurity_integration_external_oauth_propertyContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_external_oauthContext) Security_integration_external_oauth_property(i int) ISecurity_integration_external_oauth_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecurity_integration_external_oauth_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISecurity_integration_external_oauth_propertyContext) +} + +func (s *Alter_security_integration_external_oauthContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_security_integration_external_oauthContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_security_integration_external_oauthContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_security_integration_external_oauthContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_security_integration_external_oauthContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_security_integration_external_oauthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_security_integration_external_oauthContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_security_integration_external_oauth(s) + } +} + +func (s *Alter_security_integration_external_oauthContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_security_integration_external_oauth(s) + } +} + +func (s *Alter_security_integration_external_oauthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_security_integration_external_oauth(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_security_integration_external_oauth() (localctx IAlter_security_integration_external_oauthContext) { + localctx = NewAlter_security_integration_external_oauthContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, SnowflakeParserRULE_alter_security_integration_external_oauth) + var _la int + + p.SetState(4010) + 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(3872) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(3873) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3876) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3877) + p.If_exists() + } + { + p.SetState(3878) + p.Id_() + } + { + p.SetState(3879) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(3880) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3881) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3882) + p.Match(SnowflakeParserEXTERNAL_OAUTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(3885) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3886) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3887) + p.True_false() + } + + } + p.SetState(3893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_TYPE { + { + p.SetState(3890) + p.Match(SnowflakeParserEXTERNAL_OAUTH_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3891) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3892) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAZURE || _la == SnowflakeParserCUSTOM || _la == SnowflakeParserOKTA || _la == SnowflakeParserPING_FEDERATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(3898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_ISSUER { + { + p.SetState(3895) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ISSUER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3896) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3897) + p.String_() + } + + } + p.SetState(3909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM { + { + p.SetState(3900) + p.Match(SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3901) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(3902) + p.String_() + } + + case SnowflakeParserLR_BRACKET: + { + p.SetState(3903) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3904) + p.String_list() + } + { + p.SetState(3905) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(3914) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE { + { + p.SetState(3911) + p.Match(SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3912) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3913) + p.String_() + } + + } + p.SetState(3919) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 346, p.GetParserRuleContext()) == 1 { + { + p.SetState(3916) + p.Match(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3917) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3918) + p.String_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL { + { + p.SetState(3921) + p.Match(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3922) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(3923) + p.String_() + } + + case SnowflakeParserLR_BRACKET: + { + p.SetState(3924) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3925) + p.String_list() + } + { + p.SetState(3926) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(3935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY { + { + p.SetState(3932) + p.Match(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3933) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3934) + p.String_() + } + + } + p.SetState(3940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2 { + { + p.SetState(3937) + p.Match(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3938) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3939) + p.String_() + } + + } + p.SetState(3948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST { + { + p.SetState(3942) + p.Match(SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3943) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3944) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3945) + p.String_list() + } + { + p.SetState(3946) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3956) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST { + { + p.SetState(3950) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3951) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3952) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3953) + p.String_list() + } + { + p.SetState(3954) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST { + { + p.SetState(3958) + p.Match(SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3959) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3960) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3961) + p.String_() + } + { + p.SetState(3962) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3969) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 354, p.GetParserRuleContext()) == 1 { + { + p.SetState(3966) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3967) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3968) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-239)) & ^0x3f) == 0 && ((int64(1)<<(_la-239))&1310721) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE { + { + p.SetState(3971) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3972) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3973) + p.String_() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3976) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(3977) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3980) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3982) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 357, p.GetParserRuleContext()) == 1 { + { + p.SetState(3981) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3984) + p.Id_() + } + { + p.SetState(3985) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3986) + p.Security_integration_external_oauth_property() + } + p.SetState(3991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(3987) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3988) + p.Security_integration_external_oauth_property() + } + + p.SetState(3993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3994) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(3995) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3998) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3999) + p.Id_() + } + { + p.SetState(4000) + p.Set_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4002) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4003) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4006) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4007) + p.Id_() + } + { + p.SetState(4008) + p.Unset_tags() + } + + 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 +} + +// ISecurity_integration_external_oauth_propertyContext is an interface to support dynamic dispatch. +type ISecurity_integration_external_oauth_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLED() antlr.TerminalNode + NETWORK_POLICY() antlr.TerminalNode + OAUTH_CLIENT_RSA_PUBLIC_KEY() antlr.TerminalNode + OAUTH_CLIENT_RSA_PUBLIC_KEY_2() antlr.TerminalNode + OAUTH_USE_SECONDARY_ROLES() antlr.TerminalNode + EQ() antlr.TerminalNode + IMPLICIT() antlr.TerminalNode + NONE() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsSecurity_integration_external_oauth_propertyContext differentiates from other interfaces. + IsSecurity_integration_external_oauth_propertyContext() +} + +type Security_integration_external_oauth_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecurity_integration_external_oauth_propertyContext() *Security_integration_external_oauth_propertyContext { + var p = new(Security_integration_external_oauth_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_security_integration_external_oauth_property + return p +} + +func InitEmptySecurity_integration_external_oauth_propertyContext(p *Security_integration_external_oauth_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_security_integration_external_oauth_property +} + +func (*Security_integration_external_oauth_propertyContext) IsSecurity_integration_external_oauth_propertyContext() { +} + +func NewSecurity_integration_external_oauth_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_integration_external_oauth_propertyContext { + var p = new(Security_integration_external_oauth_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_security_integration_external_oauth_property + + return p +} + +func (s *Security_integration_external_oauth_propertyContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Security_integration_external_oauth_propertyContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) NETWORK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK_POLICY, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) OAUTH_CLIENT_RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) OAUTH_CLIENT_RSA_PUBLIC_KEY_2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY_2, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) OAUTH_USE_SECONDARY_ROLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_USE_SECONDARY_ROLES, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) IMPLICIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMPLICIT, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Security_integration_external_oauth_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Security_integration_external_oauth_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Security_integration_external_oauth_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSecurity_integration_external_oauth_property(s) + } +} + +func (s *Security_integration_external_oauth_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSecurity_integration_external_oauth_property(s) + } +} + +func (s *Security_integration_external_oauth_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSecurity_integration_external_oauth_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Security_integration_external_oauth_property() (localctx ISecurity_integration_external_oauth_propertyContext) { + localctx = NewSecurity_integration_external_oauth_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, SnowflakeParserRULE_security_integration_external_oauth_property) + var _la int + + p.SetState(4020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserENABLED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4012) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNETWORK_POLICY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4013) + p.Match(SnowflakeParserNETWORK_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4014) + p.Match(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY_2: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4015) + p.Match(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY_2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserOAUTH_USE_SECONDARY_ROLES: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4016) + p.Match(SnowflakeParserOAUTH_USE_SECONDARY_ROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4017) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4018) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserIMPLICIT || _la == SnowflakeParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserCOMMENT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4019) + p.Match(SnowflakeParserCOMMENT) + 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 +} + +// IAlter_security_integration_snowflake_oauthContext is an interface to support dynamic dispatch. +type IAlter_security_integration_snowflake_oauthContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + SET() antlr.TerminalNode + EXTERNAL_OAUTH_SCOPE_DELIMITER() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + SECURITY() antlr.TerminalNode + If_exists() IIf_existsContext + TYPE() antlr.TerminalNode + EXTERNAL_OAUTH() antlr.TerminalNode + Enabled_true_false() IEnabled_true_falseContext + EXTERNAL_OAUTH_TYPE() antlr.TerminalNode + EXTERNAL_OAUTH_ISSUER() antlr.TerminalNode + EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM() antlr.TerminalNode + EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE() antlr.TerminalNode + AllEXTERNAL_OAUTH_JWS_KEYS_URL() []antlr.TerminalNode + EXTERNAL_OAUTH_JWS_KEYS_URL(i int) antlr.TerminalNode + EXTERNAL_OAUTH_RSA_PUBLIC_KEY() antlr.TerminalNode + EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2() antlr.TerminalNode + EXTERNAL_OAUTH_BLOCKED_ROLES_LIST() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllString_list() []IString_listContext + String_list(i int) IString_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + EXTERNAL_OAUTH_ALLOWED_ROLES_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_ANY_ROLE_MODE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENABLE_FOR_PRIVILEGE() antlr.TerminalNode + OKTA() antlr.TerminalNode + AZURE() antlr.TerminalNode + PING_FEDERATE() antlr.TerminalNode + CUSTOM() antlr.TerminalNode + UNSET() antlr.TerminalNode + AllSecurity_integration_snowflake_oauth_property() []ISecurity_integration_snowflake_oauth_propertyContext + Security_integration_snowflake_oauth_property(i int) ISecurity_integration_snowflake_oauth_propertyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + + // IsAlter_security_integration_snowflake_oauthContext differentiates from other interfaces. + IsAlter_security_integration_snowflake_oauthContext() +} + +type Alter_security_integration_snowflake_oauthContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_security_integration_snowflake_oauthContext() *Alter_security_integration_snowflake_oauthContext { + var p = new(Alter_security_integration_snowflake_oauthContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_snowflake_oauth + return p +} + +func InitEmptyAlter_security_integration_snowflake_oauthContext(p *Alter_security_integration_snowflake_oauthContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_snowflake_oauth +} + +func (*Alter_security_integration_snowflake_oauthContext) IsAlter_security_integration_snowflake_oauthContext() { +} + +func NewAlter_security_integration_snowflake_oauthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_security_integration_snowflake_oauthContext { + var p = new(Alter_security_integration_snowflake_oauthContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_snowflake_oauth + + return p +} + +func (s *Alter_security_integration_snowflake_oauthContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_security_integration_snowflake_oauthContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_security_integration_snowflake_oauthContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_SCOPE_DELIMITER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_snowflake_oauthContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_security_integration_snowflake_oauthContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_security_integration_snowflake_oauthContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) Enabled_true_false() IEnabled_true_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnabled_true_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnabled_true_falseContext) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_TYPE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_ISSUER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ISSUER, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AllEXTERNAL_OAUTH_JWS_KEYS_URL() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_JWS_KEYS_URL(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, i) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_BLOCKED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Alter_security_integration_snowflake_oauthContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AllString_list() []IString_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_listContext); ok { + len++ + } + } + + tst := make([]IString_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_listContext); ok { + tst[i] = t.(IString_listContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_snowflake_oauthContext) String_list(i int) IString_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Alter_security_integration_snowflake_oauthContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_ALLOWED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EXTERNAL_OAUTH_ANY_ROLE_MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) DISABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) ENABLE_FOR_PRIVILEGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_FOR_PRIVILEGE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) OKTA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOKTA, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AZURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) PING_FEDERATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPING_FEDERATE, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) CUSTOM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCUSTOM, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AllSecurity_integration_snowflake_oauth_property() []ISecurity_integration_snowflake_oauth_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISecurity_integration_snowflake_oauth_propertyContext); ok { + len++ + } + } + + tst := make([]ISecurity_integration_snowflake_oauth_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISecurity_integration_snowflake_oauth_propertyContext); ok { + tst[i] = t.(ISecurity_integration_snowflake_oauth_propertyContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_snowflake_oauthContext) Security_integration_snowflake_oauth_property(i int) ISecurity_integration_snowflake_oauth_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecurity_integration_snowflake_oauth_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISecurity_integration_snowflake_oauth_propertyContext) +} + +func (s *Alter_security_integration_snowflake_oauthContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_security_integration_snowflake_oauthContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_security_integration_snowflake_oauthContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_security_integration_snowflake_oauthContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_security_integration_snowflake_oauthContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_security_integration_snowflake_oauthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_security_integration_snowflake_oauthContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_security_integration_snowflake_oauth(s) + } +} + +func (s *Alter_security_integration_snowflake_oauthContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_security_integration_snowflake_oauth(s) + } +} + +func (s *Alter_security_integration_snowflake_oauthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_security_integration_snowflake_oauth(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_security_integration_snowflake_oauth() (localctx IAlter_security_integration_snowflake_oauthContext) { + localctx = NewAlter_security_integration_snowflake_oauthContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, SnowflakeParserRULE_alter_security_integration_snowflake_oauth) + var _la int + + p.SetState(4161) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 386, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4022) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4023) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4026) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4028) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 364, p.GetParserRuleContext()) == 1 { + { + p.SetState(4027) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4030) + p.Id_() + } + { + p.SetState(4031) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(4032) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4033) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4034) + p.Match(SnowflakeParserEXTERNAL_OAUTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(4037) + p.Enabled_true_false() + } + + } + p.SetState(4043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_TYPE { + { + p.SetState(4040) + p.Match(SnowflakeParserEXTERNAL_OAUTH_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4041) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4042) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAZURE || _la == SnowflakeParserCUSTOM || _la == SnowflakeParserOKTA || _la == SnowflakeParserPING_FEDERATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_ISSUER { + { + p.SetState(4045) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ISSUER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4046) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4047) + p.String_() + } + + } + p.SetState(4059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM { + { + p.SetState(4050) + p.Match(SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4051) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4057) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(4052) + p.String_() + } + + case SnowflakeParserLR_BRACKET: + { + p.SetState(4053) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4054) + p.String_list() + } + { + p.SetState(4055) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(4064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE { + { + p.SetState(4061) + p.Match(SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4062) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4063) + p.String_() + } + + } + p.SetState(4069) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 372, p.GetParserRuleContext()) == 1 { + { + p.SetState(4066) + p.Match(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4067) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4068) + p.String_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL { + { + p.SetState(4071) + p.Match(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4072) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(4073) + p.String_() + } + + case SnowflakeParserLR_BRACKET: + { + p.SetState(4074) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4075) + p.String_list() + } + { + p.SetState(4076) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(4085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY { + { + p.SetState(4082) + p.Match(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4083) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4084) + p.String_() + } + + } + p.SetState(4090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2 { + { + p.SetState(4087) + p.Match(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4088) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4089) + p.String_() + } + + } + p.SetState(4098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST { + { + p.SetState(4092) + p.Match(SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4093) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4094) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4095) + p.String_list() + } + { + p.SetState(4096) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST { + { + p.SetState(4100) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4101) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4102) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4103) + p.String_list() + } + { + p.SetState(4104) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST { + { + p.SetState(4108) + p.Match(SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4109) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4110) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4111) + p.String_() + } + { + p.SetState(4112) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE: + { + p.SetState(4116) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4117) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4118) + p.Match(SnowflakeParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserENABLE: + { + p.SetState(4119) + p.Match(SnowflakeParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserENABLE_FOR_PRIVILEGE: + { + p.SetState(4120) + p.Match(SnowflakeParserENABLE_FOR_PRIVILEGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER: + + default: + } + + { + p.SetState(4123) + p.Match(SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4124) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4125) + p.String_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4127) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4128) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4131) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4133) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 382, p.GetParserRuleContext()) == 1 { + { + p.SetState(4132) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4135) + p.Id_() + } + { + p.SetState(4136) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4137) + p.Security_integration_snowflake_oauth_property() + } + p.SetState(4142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(4138) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4139) + p.Security_integration_snowflake_oauth_property() + } + + p.SetState(4144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4145) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4146) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4149) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4150) + p.Id_() + } + { + p.SetState(4151) + p.Set_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4153) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4154) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4157) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4158) + p.Id_() + } + { + p.SetState(4159) + p.Unset_tags() + } + + 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 +} + +// ISecurity_integration_snowflake_oauth_propertyContext is an interface to support dynamic dispatch. +type ISecurity_integration_snowflake_oauth_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLED() antlr.TerminalNode + EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode + + // IsSecurity_integration_snowflake_oauth_propertyContext differentiates from other interfaces. + IsSecurity_integration_snowflake_oauth_propertyContext() +} + +type Security_integration_snowflake_oauth_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecurity_integration_snowflake_oauth_propertyContext() *Security_integration_snowflake_oauth_propertyContext { + var p = new(Security_integration_snowflake_oauth_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_security_integration_snowflake_oauth_property + return p +} + +func InitEmptySecurity_integration_snowflake_oauth_propertyContext(p *Security_integration_snowflake_oauth_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_security_integration_snowflake_oauth_property +} + +func (*Security_integration_snowflake_oauth_propertyContext) IsSecurity_integration_snowflake_oauth_propertyContext() { +} + +func NewSecurity_integration_snowflake_oauth_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_integration_snowflake_oauth_propertyContext { + var p = new(Security_integration_snowflake_oauth_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_security_integration_snowflake_oauth_property + + return p +} + +func (s *Security_integration_snowflake_oauth_propertyContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Security_integration_snowflake_oauth_propertyContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Security_integration_snowflake_oauth_propertyContext) EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, 0) +} + +func (s *Security_integration_snowflake_oauth_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Security_integration_snowflake_oauth_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Security_integration_snowflake_oauth_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSecurity_integration_snowflake_oauth_property(s) + } +} + +func (s *Security_integration_snowflake_oauth_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSecurity_integration_snowflake_oauth_property(s) + } +} + +func (s *Security_integration_snowflake_oauth_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSecurity_integration_snowflake_oauth_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Security_integration_snowflake_oauth_property() (localctx ISecurity_integration_snowflake_oauth_propertyContext) { + localctx = NewSecurity_integration_snowflake_oauth_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, SnowflakeParserRULE_security_integration_snowflake_oauth_property) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4163) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserENABLED || _la == SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST) { + 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 +} + +// IAlter_security_integration_saml2Context is an interface to support dynamic dispatch. +type IAlter_security_integration_saml2Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + SET() antlr.TerminalNode + SECURITY() antlr.TerminalNode + If_exists() IIf_existsContext + TYPE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + SAML2() antlr.TerminalNode + Enabled_true_false() IEnabled_true_falseContext + SAML2_ISSUER() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + SAML2_SSO_URL() antlr.TerminalNode + SAML2_PROVIDER() antlr.TerminalNode + SAML2_X509_CERT() antlr.TerminalNode + SAML2_SP_INITIATED_LOGIN_PAGE_LABEL() antlr.TerminalNode + SAML2_ENABLE_SP_INITIATED() antlr.TerminalNode + AllTrue_false() []ITrue_falseContext + True_false(i int) ITrue_falseContext + SAML2_SNOWFLAKE_X509_CERT() antlr.TerminalNode + SAML2_SIGN_REQUEST() antlr.TerminalNode + SAML2_REQUESTED_NAMEID_FORMAT() antlr.TerminalNode + SAML2_POST_LOGOUT_REDIRECT_URL() antlr.TerminalNode + SAML2_FORCE_AUTHN() antlr.TerminalNode + SAML2_SNOWFLAKE_ISSUER_URL() antlr.TerminalNode + SAML2_SNOWFLAKE_ACS_URL() antlr.TerminalNode + UNSET() antlr.TerminalNode + ENABLED() antlr.TerminalNode + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + + // IsAlter_security_integration_saml2Context differentiates from other interfaces. + IsAlter_security_integration_saml2Context() +} + +type Alter_security_integration_saml2Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_security_integration_saml2Context() *Alter_security_integration_saml2Context { + var p = new(Alter_security_integration_saml2Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_saml2 + return p +} + +func InitEmptyAlter_security_integration_saml2Context(p *Alter_security_integration_saml2Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_saml2 +} + +func (*Alter_security_integration_saml2Context) IsAlter_security_integration_saml2Context() {} + +func NewAlter_security_integration_saml2Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_security_integration_saml2Context { + var p = new(Alter_security_integration_saml2Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_saml2 + + return p +} + +func (s *Alter_security_integration_saml2Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_security_integration_saml2Context) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_security_integration_saml2Context) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Alter_security_integration_saml2Context) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_security_integration_saml2Context) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_security_integration_saml2Context) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Alter_security_integration_saml2Context) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_security_integration_saml2Context) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Alter_security_integration_saml2Context) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_security_integration_saml2Context) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_security_integration_saml2Context) SAML2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2, 0) +} + +func (s *Alter_security_integration_saml2Context) Enabled_true_false() IEnabled_true_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnabled_true_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnabled_true_falseContext) +} + +func (s *Alter_security_integration_saml2Context) SAML2_ISSUER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_ISSUER, 0) +} + +func (s *Alter_security_integration_saml2Context) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_saml2Context) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_security_integration_saml2Context) SAML2_SSO_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SSO_URL, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_PROVIDER, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_X509_CERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_X509_CERT, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_SP_INITIATED_LOGIN_PAGE_LABEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SP_INITIATED_LOGIN_PAGE_LABEL, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_ENABLE_SP_INITIATED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_ENABLE_SP_INITIATED, 0) +} + +func (s *Alter_security_integration_saml2Context) AllTrue_false() []ITrue_falseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrue_falseContext); ok { + len++ + } + } + + tst := make([]ITrue_falseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrue_falseContext); ok { + tst[i] = t.(ITrue_falseContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_saml2Context) True_false(i int) ITrue_falseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_security_integration_saml2Context) SAML2_SNOWFLAKE_X509_CERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SNOWFLAKE_X509_CERT, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_SIGN_REQUEST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SIGN_REQUEST, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_REQUESTED_NAMEID_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_REQUESTED_NAMEID_FORMAT, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_POST_LOGOUT_REDIRECT_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_POST_LOGOUT_REDIRECT_URL, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_FORCE_AUTHN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_FORCE_AUTHN, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_SNOWFLAKE_ISSUER_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SNOWFLAKE_ISSUER_URL, 0) +} + +func (s *Alter_security_integration_saml2Context) SAML2_SNOWFLAKE_ACS_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SNOWFLAKE_ACS_URL, 0) +} + +func (s *Alter_security_integration_saml2Context) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_security_integration_saml2Context) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Alter_security_integration_saml2Context) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_security_integration_saml2Context) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_security_integration_saml2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_security_integration_saml2Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_security_integration_saml2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_security_integration_saml2(s) + } +} + +func (s *Alter_security_integration_saml2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_security_integration_saml2(s) + } +} + +func (s *Alter_security_integration_saml2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_security_integration_saml2(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_security_integration_saml2() (localctx IAlter_security_integration_saml2Context) { + localctx = NewAlter_security_integration_saml2Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, SnowflakeParserRULE_alter_security_integration_saml2) + var _la int + + p.SetState(4276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 408, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4165) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4166) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4169) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4171) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 388, p.GetParserRuleContext()) == 1 { + { + p.SetState(4170) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4173) + p.Id_() + } + { + p.SetState(4174) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(4175) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4176) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4177) + p.Match(SnowflakeParserSAML2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(4180) + p.Enabled_true_false() + } + + } + p.SetState(4186) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_ISSUER { + { + p.SetState(4183) + p.Match(SnowflakeParserSAML2_ISSUER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4184) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4185) + p.String_() + } + + } + p.SetState(4191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SSO_URL { + { + p.SetState(4188) + p.Match(SnowflakeParserSAML2_SSO_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4189) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4190) + p.String_() + } + + } + p.SetState(4196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_PROVIDER { + { + p.SetState(4193) + p.Match(SnowflakeParserSAML2_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4194) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4195) + p.String_() + } + + } + p.SetState(4201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_X509_CERT { + { + p.SetState(4198) + p.Match(SnowflakeParserSAML2_X509_CERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4199) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4200) + p.String_() + } + + } + p.SetState(4206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SP_INITIATED_LOGIN_PAGE_LABEL { + { + p.SetState(4203) + p.Match(SnowflakeParserSAML2_SP_INITIATED_LOGIN_PAGE_LABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4204) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4205) + p.String_() + } + + } + p.SetState(4211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_ENABLE_SP_INITIATED { + { + p.SetState(4208) + p.Match(SnowflakeParserSAML2_ENABLE_SP_INITIATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4209) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4210) + p.True_false() + } + + } + p.SetState(4216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SNOWFLAKE_X509_CERT { + { + p.SetState(4213) + p.Match(SnowflakeParserSAML2_SNOWFLAKE_X509_CERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4214) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4215) + p.String_() + } + + } + p.SetState(4221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SIGN_REQUEST { + { + p.SetState(4218) + p.Match(SnowflakeParserSAML2_SIGN_REQUEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4219) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4220) + p.True_false() + } + + } + p.SetState(4226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_REQUESTED_NAMEID_FORMAT { + { + p.SetState(4223) + p.Match(SnowflakeParserSAML2_REQUESTED_NAMEID_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4224) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4225) + p.String_() + } + + } + p.SetState(4231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_POST_LOGOUT_REDIRECT_URL { + { + p.SetState(4228) + p.Match(SnowflakeParserSAML2_POST_LOGOUT_REDIRECT_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4229) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4230) + p.String_() + } + + } + p.SetState(4236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_FORCE_AUTHN { + { + p.SetState(4233) + p.Match(SnowflakeParserSAML2_FORCE_AUTHN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4234) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4235) + p.True_false() + } + + } + p.SetState(4241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SNOWFLAKE_ISSUER_URL { + { + p.SetState(4238) + p.Match(SnowflakeParserSAML2_SNOWFLAKE_ISSUER_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4239) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4240) + p.String_() + } + + } + p.SetState(4246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SNOWFLAKE_ACS_URL { + { + p.SetState(4243) + p.Match(SnowflakeParserSAML2_SNOWFLAKE_ACS_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4244) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4245) + p.String_() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4248) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4249) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4252) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4254) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 405, p.GetParserRuleContext()) == 1 { + { + p.SetState(4253) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4256) + p.Id_() + } + { + p.SetState(4257) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4258) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4260) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4262) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4261) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4264) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4265) + p.Id_() + } + { + p.SetState(4266) + p.Set_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4268) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4269) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4272) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4273) + p.Id_() + } + { + p.SetState(4274) + p.Unset_tags() + } + + 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_security_integration_scimContext is an interface to support dynamic dispatch. +type IAlter_security_integration_scimContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + SET() antlr.TerminalNode + SECURITY() antlr.TerminalNode + If_exists() IIf_existsContext + NETWORK_POLICY() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + String_() IStringContext + SYNC_PASSWORD() antlr.TerminalNode + True_false() ITrue_falseContext + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + AllSecurity_integration_scim_property() []ISecurity_integration_scim_propertyContext + Security_integration_scim_property(i int) ISecurity_integration_scim_propertyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + + // IsAlter_security_integration_scimContext differentiates from other interfaces. + IsAlter_security_integration_scimContext() +} + +type Alter_security_integration_scimContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_security_integration_scimContext() *Alter_security_integration_scimContext { + var p = new(Alter_security_integration_scimContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_scim + return p +} + +func InitEmptyAlter_security_integration_scimContext(p *Alter_security_integration_scimContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_scim +} + +func (*Alter_security_integration_scimContext) IsAlter_security_integration_scimContext() {} + +func NewAlter_security_integration_scimContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_security_integration_scimContext { + var p = new(Alter_security_integration_scimContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_security_integration_scim + + return p +} + +func (s *Alter_security_integration_scimContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_security_integration_scimContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_security_integration_scimContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Alter_security_integration_scimContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_security_integration_scimContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_security_integration_scimContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Alter_security_integration_scimContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_security_integration_scimContext) NETWORK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK_POLICY, 0) +} + +func (s *Alter_security_integration_scimContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_security_integration_scimContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_security_integration_scimContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_security_integration_scimContext) SYNC_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYNC_PASSWORD, 0) +} + +func (s *Alter_security_integration_scimContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_security_integration_scimContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_security_integration_scimContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_security_integration_scimContext) AllSecurity_integration_scim_property() []ISecurity_integration_scim_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISecurity_integration_scim_propertyContext); ok { + len++ + } + } + + tst := make([]ISecurity_integration_scim_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISecurity_integration_scim_propertyContext); ok { + tst[i] = t.(ISecurity_integration_scim_propertyContext) + i++ + } + } + + return tst +} + +func (s *Alter_security_integration_scimContext) Security_integration_scim_property(i int) ISecurity_integration_scim_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecurity_integration_scim_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISecurity_integration_scim_propertyContext) +} + +func (s *Alter_security_integration_scimContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_security_integration_scimContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_security_integration_scimContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_security_integration_scimContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_security_integration_scimContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_security_integration_scimContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_security_integration_scimContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_security_integration_scim(s) + } +} + +func (s *Alter_security_integration_scimContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_security_integration_scim(s) + } +} + +func (s *Alter_security_integration_scimContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_security_integration_scim(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_security_integration_scim() (localctx IAlter_security_integration_scimContext) { + localctx = NewAlter_security_integration_scimContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, SnowflakeParserRULE_alter_security_integration_scim) + var _la int + + p.SetState(4335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 419, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4278) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4279) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4282) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4284) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 410, p.GetParserRuleContext()) == 1 { + { + p.SetState(4283) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4286) + p.Id_() + } + { + p.SetState(4287) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNETWORK_POLICY { + { + p.SetState(4288) + p.Match(SnowflakeParserNETWORK_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4289) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4290) + p.String_() + } + + } + p.SetState(4296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSYNC_PASSWORD { + { + p.SetState(4293) + p.Match(SnowflakeParserSYNC_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4294) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4295) + p.True_false() + } + + } + p.SetState(4299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(4298) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4301) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4302) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4305) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4307) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 415, p.GetParserRuleContext()) == 1 { + { + p.SetState(4306) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4309) + p.Id_() + } + { + p.SetState(4310) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4311) + p.Security_integration_scim_property() + } + p.SetState(4316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(4312) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4313) + p.Security_integration_scim_property() + } + + p.SetState(4318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4319) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4320) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4323) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4324) + p.Id_() + } + { + p.SetState(4325) + p.Set_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4327) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4329) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURITY { + { + p.SetState(4328) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4331) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4332) + p.Id_() + } + { + p.SetState(4333) + p.Unset_tags() + } + + 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 +} + +// ISecurity_integration_scim_propertyContext is an interface to support dynamic dispatch. +type ISecurity_integration_scim_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NETWORK_POLICY() antlr.TerminalNode + SYNC_PASSWORD() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsSecurity_integration_scim_propertyContext differentiates from other interfaces. + IsSecurity_integration_scim_propertyContext() +} + +type Security_integration_scim_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecurity_integration_scim_propertyContext() *Security_integration_scim_propertyContext { + var p = new(Security_integration_scim_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_security_integration_scim_property + return p +} + +func InitEmptySecurity_integration_scim_propertyContext(p *Security_integration_scim_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_security_integration_scim_property +} + +func (*Security_integration_scim_propertyContext) IsSecurity_integration_scim_propertyContext() {} + +func NewSecurity_integration_scim_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_integration_scim_propertyContext { + var p = new(Security_integration_scim_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_security_integration_scim_property + + return p +} + +func (s *Security_integration_scim_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Security_integration_scim_propertyContext) NETWORK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK_POLICY, 0) +} + +func (s *Security_integration_scim_propertyContext) SYNC_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYNC_PASSWORD, 0) +} + +func (s *Security_integration_scim_propertyContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Security_integration_scim_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Security_integration_scim_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Security_integration_scim_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSecurity_integration_scim_property(s) + } +} + +func (s *Security_integration_scim_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSecurity_integration_scim_property(s) + } +} + +func (s *Security_integration_scim_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSecurity_integration_scim_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Security_integration_scim_property() (localctx ISecurity_integration_scim_propertyContext) { + localctx = NewSecurity_integration_scim_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, SnowflakeParserRULE_security_integration_scim_property) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4337) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOMMENT || _la == SnowflakeParserNETWORK_POLICY || _la == SnowflakeParserSYNC_PASSWORD) { + 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 +} + +// IAlter_sequenceContext is an interface to support dynamic dispatch. +type IAlter_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SET() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + Num() INumContext + BY() antlr.TerminalNode + EQ() antlr.TerminalNode + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlter_sequenceContext differentiates from other interfaces. + IsAlter_sequenceContext() +} + +type Alter_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_sequenceContext() *Alter_sequenceContext { + var p = new(Alter_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_sequence + return p +} + +func InitEmptyAlter_sequenceContext(p *Alter_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_sequence +} + +func (*Alter_sequenceContext) IsAlter_sequenceContext() {} + +func NewAlter_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_sequenceContext { + var p = new(Alter_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_sequence + + return p +} + +func (s *Alter_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_sequenceContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 0) +} + +func (s *Alter_sequenceContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_sequenceContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_sequenceContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_sequenceContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_sequenceContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_sequenceContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_sequenceContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINCREMENT, 0) +} + +func (s *Alter_sequenceContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Alter_sequenceContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Alter_sequenceContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Alter_sequenceContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_sequenceContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_sequenceContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_sequence(s) + } +} + +func (s *Alter_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_sequence(s) + } +} + +func (s *Alter_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_sequence() (localctx IAlter_sequenceContext) { + localctx = NewAlter_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, SnowflakeParserRULE_alter_sequence) + var _la int + + p.SetState(4386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 428, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4339) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4340) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4342) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 420, p.GetParserRuleContext()) == 1 { + { + p.SetState(4341) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4344) + p.Id_() + } + { + p.SetState(4345) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4346) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4347) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4349) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4350) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4352) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 421, p.GetParserRuleContext()) == 1 { + { + p.SetState(4351) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4354) + p.Id_() + } + p.SetState(4356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET { + { + p.SetState(4355) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserINCREMENT { + { + p.SetState(4358) + p.Match(SnowflakeParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserBY { + { + p.SetState(4359) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEQ { + { + p.SetState(4362) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4365) + p.Num() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4368) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4369) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4371) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 426, p.GetParserRuleContext()) == 1 { + { + p.SetState(4370) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4373) + p.Id_() + } + { + p.SetState(4374) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4375) + p.Comment_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4377) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4378) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4380) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 427, p.GetParserRuleContext()) == 1 { + { + p.SetState(4379) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4382) + p.Id_() + } + { + p.SetState(4383) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4384) + p.Match(SnowflakeParserCOMMENT) + 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 +} + +// IAlter_sessionContext is an interface to support dynamic dispatch. +type IAlter_sessionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SESSION() antlr.TerminalNode + SET() antlr.TerminalNode + Session_params() ISession_paramsContext + UNSET() antlr.TerminalNode + AllParam_name() []IParam_nameContext + Param_name(i int) IParam_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_sessionContext differentiates from other interfaces. + IsAlter_sessionContext() +} + +type Alter_sessionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_sessionContext() *Alter_sessionContext { + var p = new(Alter_sessionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_session + return p +} + +func InitEmptyAlter_sessionContext(p *Alter_sessionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_session +} + +func (*Alter_sessionContext) IsAlter_sessionContext() {} + +func NewAlter_sessionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_sessionContext { + var p = new(Alter_sessionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_session + + return p +} + +func (s *Alter_sessionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_sessionContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_sessionContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Alter_sessionContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_sessionContext) Session_params() ISession_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISession_paramsContext) +} + +func (s *Alter_sessionContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_sessionContext) AllParam_name() []IParam_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParam_nameContext); ok { + len++ + } + } + + tst := make([]IParam_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParam_nameContext); ok { + tst[i] = t.(IParam_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_sessionContext) Param_name(i int) IParam_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParam_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParam_nameContext) +} + +func (s *Alter_sessionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_sessionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_sessionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_sessionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_sessionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_session(s) + } +} + +func (s *Alter_sessionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_session(s) + } +} + +func (s *Alter_sessionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_session(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_session() (localctx IAlter_sessionContext) { + localctx = NewAlter_sessionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, SnowflakeParserRULE_alter_session) + var _la int + + p.SetState(4403) + 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(4388) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4389) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4390) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4391) + p.Session_params() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4392) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4393) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4394) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4395) + p.Param_name() + } + p.SetState(4400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(4396) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4397) + p.Param_name() + } + + p.SetState(4402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + 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_session_policyContext is an interface to support dynamic dispatch. +type IAlter_session_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SESSION() antlr.TerminalNode + POLICY() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + UNSET() antlr.TerminalNode + SET() antlr.TerminalNode + If_exists() IIf_existsContext + SESSION_IDLE_TIMEOUT_MINS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + SESSION_UI_IDLE_TIMEOUT_MINS() antlr.TerminalNode + Comment_clause() IComment_clauseContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + + // IsAlter_session_policyContext differentiates from other interfaces. + IsAlter_session_policyContext() +} + +type Alter_session_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_session_policyContext() *Alter_session_policyContext { + var p = new(Alter_session_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_session_policy + return p +} + +func InitEmptyAlter_session_policyContext(p *Alter_session_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_session_policy +} + +func (*Alter_session_policyContext) IsAlter_session_policyContext() {} + +func NewAlter_session_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_session_policyContext { + var p = new(Alter_session_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_session_policy + + return p +} + +func (s *Alter_session_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_session_policyContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_session_policyContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Alter_session_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Alter_session_policyContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_session_policyContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_session_policyContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_session_policyContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_session_policyContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_session_policyContext) SESSION_IDLE_TIMEOUT_MINS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, 0) +} + +func (s *Alter_session_policyContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_session_policyContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_session_policyContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Alter_session_policyContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Alter_session_policyContext) SESSION_UI_IDLE_TIMEOUT_MINS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, 0) +} + +func (s *Alter_session_policyContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_session_policyContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_session_policyContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_session_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_session_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_session_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_session_policy(s) + } +} + +func (s *Alter_session_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_session_policy(s) + } +} + +func (s *Alter_session_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_session_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_session_policy() (localctx IAlter_session_policyContext) { + localctx = NewAlter_session_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, SnowflakeParserRULE_alter_session_policy) + var _la int + + p.SetState(4437) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 436, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4405) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4406) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4407) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4409) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 431, p.GetParserRuleContext()) == 1 { + { + p.SetState(4408) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4411) + p.Id_() + } + { + p.SetState(4412) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserSET || _la == SnowflakeParserUNSET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSESSION_IDLE_TIMEOUT_MINS { + { + p.SetState(4413) + p.Match(SnowflakeParserSESSION_IDLE_TIMEOUT_MINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4414) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4415) + p.Num() + } + + } + p.SetState(4421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS { + { + p.SetState(4418) + p.Match(SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4419) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4420) + p.Num() + } + + } + p.SetState(4424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(4423) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4426) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4427) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4428) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4430) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 435, p.GetParserRuleContext()) == 1 { + { + p.SetState(4429) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4432) + p.Id_() + } + { + p.SetState(4433) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4434) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4435) + p.Id_() + } + + 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_shareContext is an interface to support dynamic dispatch. +type IAlter_shareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SHARE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ACCOUNTS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + ADD() antlr.TerminalNode + REMOVE() antlr.TerminalNode + If_exists() IIf_existsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SHARE_RESTRICTIONS() antlr.TerminalNode + True_false() ITrue_falseContext + SET() antlr.TerminalNode + Comment_clause() IComment_clauseContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlter_shareContext differentiates from other interfaces. + IsAlter_shareContext() +} + +type Alter_shareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_shareContext() *Alter_shareContext { + var p = new(Alter_shareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_share + return p +} + +func InitEmptyAlter_shareContext(p *Alter_shareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_share +} + +func (*Alter_shareContext) IsAlter_shareContext() {} + +func NewAlter_shareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_shareContext { + var p = new(Alter_shareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_share + + return p +} + +func (s *Alter_shareContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_shareContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_shareContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Alter_shareContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_shareContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_shareContext) ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTS, 0) +} + +func (s *Alter_shareContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_shareContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_shareContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_shareContext) REMOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOVE, 0) +} + +func (s *Alter_shareContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_shareContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_shareContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_shareContext) SHARE_RESTRICTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE_RESTRICTIONS, 0) +} + +func (s *Alter_shareContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_shareContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_shareContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_shareContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_shareContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_shareContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_shareContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_shareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_shareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_shareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_share(s) + } +} + +func (s *Alter_shareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_share(s) + } +} + +func (s *Alter_shareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_share(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_share() (localctx IAlter_shareContext) { + localctx = NewAlter_shareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, SnowflakeParserRULE_alter_share) + var _la int + + p.SetState(4527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 449, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4439) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4440) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4442) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 437, p.GetParserRuleContext()) == 1 { + { + p.SetState(4441) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4444) + p.Id_() + } + { + p.SetState(4445) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserADD || _la == SnowflakeParserREMOVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4446) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4447) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4448) + p.Id_() + } + p.SetState(4453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(4449) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4450) + p.Id_() + } + + p.SetState(4455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSHARE_RESTRICTIONS { + { + p.SetState(4456) + p.Match(SnowflakeParserSHARE_RESTRICTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4457) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4458) + p.True_false() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4461) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4462) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4464) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) == 1 { + { + p.SetState(4463) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4466) + p.Id_() + } + { + p.SetState(4467) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4468) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4469) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4470) + p.Id_() + } + p.SetState(4475) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(4471) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4472) + p.Id_() + } + + p.SetState(4477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSHARE_RESTRICTIONS { + { + p.SetState(4478) + p.Match(SnowflakeParserSHARE_RESTRICTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4479) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4480) + p.True_false() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4483) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4484) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4486) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 443, p.GetParserRuleContext()) == 1 { + { + p.SetState(4485) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4488) + p.Id_() + } + { + p.SetState(4489) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserACCOUNTS { + { + p.SetState(4490) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4491) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4492) + p.Id_() + } + p.SetState(4497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(4493) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4494) + p.Id_() + } + + p.SetState(4499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(4503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(4502) + p.Comment_clause() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4505) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4506) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4508) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 447, p.GetParserRuleContext()) == 1 { + { + p.SetState(4507) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4510) + p.Id_() + } + { + p.SetState(4511) + p.Set_tags() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4513) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4514) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4515) + p.Id_() + } + { + p.SetState(4516) + p.Unset_tags() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4518) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4519) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4521) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 448, p.GetParserRuleContext()) == 1 { + { + p.SetState(4520) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4523) + p.Id_() + } + { + p.SetState(4524) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4525) + p.Match(SnowflakeParserCOMMENT) + 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 +} + +// IAlter_stageContext is an interface to support dynamic dispatch. +type IAlter_stageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + STAGE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + SET() antlr.TerminalNode + Comment_clause() IComment_clauseContext + Internal_stage_params() IInternal_stage_paramsContext + File_format() IFile_formatContext + COPY_OPTIONS_() antlr.TerminalNode + EQ() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Copy_options() ICopy_optionsContext + RR_BRACKET() antlr.TerminalNode + External_stage_params() IExternal_stage_paramsContext + + // IsAlter_stageContext differentiates from other interfaces. + IsAlter_stageContext() +} + +type Alter_stageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_stageContext() *Alter_stageContext { + var p = new(Alter_stageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_stage + return p +} + +func InitEmptyAlter_stageContext(p *Alter_stageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_stage +} + +func (*Alter_stageContext) IsAlter_stageContext() {} + +func NewAlter_stageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_stageContext { + var p = new(Alter_stageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_stage + + return p +} + +func (s *Alter_stageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_stageContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_stageContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Alter_stageContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_stageContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_stageContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_stageContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_stageContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_stageContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_stageContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_stageContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_stageContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_stageContext) Internal_stage_params() IInternal_stage_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInternal_stage_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInternal_stage_paramsContext) +} + +func (s *Alter_stageContext) File_format() IFile_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_formatContext) +} + +func (s *Alter_stageContext) COPY_OPTIONS_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY_OPTIONS_, 0) +} + +func (s *Alter_stageContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Alter_stageContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_stageContext) 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 *Alter_stageContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_stageContext) External_stage_params() IExternal_stage_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_stage_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_stage_paramsContext) +} + +func (s *Alter_stageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_stageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_stageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_stage(s) + } +} + +func (s *Alter_stageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_stage(s) + } +} + +func (s *Alter_stageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_stage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_stage() (localctx IAlter_stageContext) { + localctx = NewAlter_stageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, SnowflakeParserRULE_alter_stage) + var _la int + + p.SetState(4599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 461, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4529) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4530) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4532) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 450, p.GetParserRuleContext()) == 1 { + { + p.SetState(4531) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4534) + p.Id_() + } + { + p.SetState(4535) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4536) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4537) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4539) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4540) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4542) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 451, p.GetParserRuleContext()) == 1 { + { + p.SetState(4541) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4544) + p.Id_() + } + { + p.SetState(4545) + p.Set_tags() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4547) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4548) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4549) + p.Id_() + } + { + p.SetState(4550) + p.Unset_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4552) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4553) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4555) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 452, p.GetParserRuleContext()) == 1 { + { + p.SetState(4554) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4557) + p.Id_() + } + { + p.SetState(4558) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(4560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENCRYPTION || _la == SnowflakeParserTYPE { + { + p.SetState(4559) + p.Internal_stage_params() + } + + } + p.SetState(4563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILE_FORMAT { + { + p.SetState(4562) + p.File_format() + } + + } + p.SetState(4571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY_OPTIONS_ { + { + p.SetState(4565) + p.Match(SnowflakeParserCOPY_OPTIONS_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4566) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4567) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4568) + p.Copy_options() + } + { + p.SetState(4569) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4573) + p.Comment_clause() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4575) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4576) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4578) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 456, p.GetParserRuleContext()) == 1 { + { + p.SetState(4577) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4580) + p.Id_() + } + { + p.SetState(4581) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(4583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserURL { + { + p.SetState(4582) + p.External_stage_params() + } + + } + p.SetState(4586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILE_FORMAT { + { + p.SetState(4585) + p.File_format() + } + + } + p.SetState(4594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY_OPTIONS_ { + { + p.SetState(4588) + p.Match(SnowflakeParserCOPY_OPTIONS_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4589) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4590) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4591) + p.Copy_options() + } + { + p.SetState(4592) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(4596) + p.Comment_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 +} + +// IAlter_storage_integrationContext is an interface to support dynamic dispatch. +type IAlter_storage_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + SET() antlr.TerminalNode + STORAGE() antlr.TerminalNode + If_exists() IIf_existsContext + Cloud_provider_params2() ICloud_provider_params2Context + Enabled_true_false() IEnabled_true_falseContext + STORAGE_ALLOWED_LOCATIONS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllString_list() []IString_listContext + String_list(i int) IString_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + STORAGE_BLOCKED_LOCATIONS() antlr.TerminalNode + Comment_clause() IComment_clauseContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + ENABLED() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlter_storage_integrationContext differentiates from other interfaces. + IsAlter_storage_integrationContext() +} + +type Alter_storage_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_storage_integrationContext() *Alter_storage_integrationContext { + var p = new(Alter_storage_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_storage_integration + return p +} + +func InitEmptyAlter_storage_integrationContext(p *Alter_storage_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_storage_integration +} + +func (*Alter_storage_integrationContext) IsAlter_storage_integrationContext() {} + +func NewAlter_storage_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_storage_integrationContext { + var p = new(Alter_storage_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_storage_integration + + return p +} + +func (s *Alter_storage_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_storage_integrationContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_storage_integrationContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Alter_storage_integrationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_storage_integrationContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_storage_integrationContext) STORAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE, 0) +} + +func (s *Alter_storage_integrationContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_storage_integrationContext) Cloud_provider_params2() ICloud_provider_params2Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICloud_provider_params2Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICloud_provider_params2Context) +} + +func (s *Alter_storage_integrationContext) Enabled_true_false() IEnabled_true_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnabled_true_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnabled_true_falseContext) +} + +func (s *Alter_storage_integrationContext) STORAGE_ALLOWED_LOCATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, 0) +} + +func (s *Alter_storage_integrationContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_storage_integrationContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_storage_integrationContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Alter_storage_integrationContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Alter_storage_integrationContext) AllString_list() []IString_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_listContext); ok { + len++ + } + } + + tst := make([]IString_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_listContext); ok { + tst[i] = t.(IString_listContext) + i++ + } + } + + return tst +} + +func (s *Alter_storage_integrationContext) String_list(i int) IString_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Alter_storage_integrationContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Alter_storage_integrationContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Alter_storage_integrationContext) STORAGE_BLOCKED_LOCATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, 0) +} + +func (s *Alter_storage_integrationContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_storage_integrationContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_storage_integrationContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_storage_integrationContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_storage_integrationContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Alter_storage_integrationContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_storage_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_storage_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_storage_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_storage_integration(s) + } +} + +func (s *Alter_storage_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_storage_integration(s) + } +} + +func (s *Alter_storage_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_storage_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_storage_integration() (localctx IAlter_storage_integrationContext) { + localctx = NewAlter_storage_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, SnowflakeParserRULE_alter_storage_integration) + var _la int + + p.SetState(4667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 474, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4601) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE { + { + p.SetState(4602) + p.Match(SnowflakeParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4605) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4607) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 463, p.GetParserRuleContext()) == 1 { + { + p.SetState(4606) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4609) + p.Id_() + } + { + p.SetState(4610) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAZURE_TENANT_ID || _la == SnowflakeParserSTORAGE_AWS_ROLE_ARN { + { + p.SetState(4611) + p.Cloud_provider_params2() + } + + } + p.SetState(4615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(4614) + p.Enabled_true_false() + } + + } + p.SetState(4623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE_ALLOWED_LOCATIONS { + { + p.SetState(4617) + p.Match(SnowflakeParserSTORAGE_ALLOWED_LOCATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4618) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4619) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4620) + p.String_list() + } + { + p.SetState(4621) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE_BLOCKED_LOCATIONS { + { + p.SetState(4625) + p.Match(SnowflakeParserSTORAGE_BLOCKED_LOCATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4626) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4627) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4628) + p.String_list() + } + { + p.SetState(4629) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(4633) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4636) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE { + { + p.SetState(4637) + p.Match(SnowflakeParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4640) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4642) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 470, p.GetParserRuleContext()) == 1 { + { + p.SetState(4641) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4644) + p.Id_() + } + { + p.SetState(4645) + p.Set_tags() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4647) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE { + { + p.SetState(4648) + p.Match(SnowflakeParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4651) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4652) + p.Id_() + } + { + p.SetState(4653) + p.Unset_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4655) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE { + { + p.SetState(4656) + p.Match(SnowflakeParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4659) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4661) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 473, p.GetParserRuleContext()) == 1 { + { + p.SetState(4660) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4663) + p.Id_() + } + { + p.SetState(4664) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4665) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOMMENT || _la == SnowflakeParserENABLED || _la == SnowflakeParserSTORAGE_BLOCKED_LOCATIONS) { + 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 +} + +// IAlter_streamContext is an interface to support dynamic dispatch. +type IAlter_streamContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + STREAM() antlr.TerminalNode + Id_() IId_Context + SET() antlr.TerminalNode + If_exists() IIf_existsContext + Tag_decl_list() ITag_decl_listContext + Comment_clause() IComment_clauseContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlter_streamContext differentiates from other interfaces. + IsAlter_streamContext() +} + +type Alter_streamContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_streamContext() *Alter_streamContext { + var p = new(Alter_streamContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_stream + return p +} + +func InitEmptyAlter_streamContext(p *Alter_streamContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_stream +} + +func (*Alter_streamContext) IsAlter_streamContext() {} + +func NewAlter_streamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_streamContext { + var p = new(Alter_streamContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_stream + + return p +} + +func (s *Alter_streamContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_streamContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_streamContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Alter_streamContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_streamContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_streamContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_streamContext) Tag_decl_list() ITag_decl_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITag_decl_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITag_decl_listContext) +} + +func (s *Alter_streamContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_streamContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_streamContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_streamContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_streamContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_streamContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_streamContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_streamContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_stream(s) + } +} + +func (s *Alter_streamContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_stream(s) + } +} + +func (s *Alter_streamContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_stream(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_stream() (localctx IAlter_streamContext) { + localctx = NewAlter_streamContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, SnowflakeParserRULE_alter_stream) + var _la int + + p.SetState(4704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 480, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4669) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4670) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4672) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 475, p.GetParserRuleContext()) == 1 { + { + p.SetState(4671) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4674) + p.Id_() + } + { + p.SetState(4675) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG { + { + p.SetState(4676) + p.Tag_decl_list() + } + + } + p.SetState(4680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(4679) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4682) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4683) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4685) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 478, p.GetParserRuleContext()) == 1 { + { + p.SetState(4684) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4687) + p.Id_() + } + { + p.SetState(4688) + p.Set_tags() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4690) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4691) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4692) + p.Id_() + } + { + p.SetState(4693) + p.Unset_tags() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4695) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4696) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4698) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 479, p.GetParserRuleContext()) == 1 { + { + p.SetState(4697) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4700) + p.Id_() + } + { + p.SetState(4701) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4702) + p.Match(SnowflakeParserCOMMENT) + 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 +} + +// IAlter_tableContext is an interface to support dynamic dispatch. +type IAlter_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllObject_name() []IObject_nameContext + Object_name(i int) IObject_nameContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SWAP() antlr.TerminalNode + WITH() antlr.TerminalNode + Clustering_action() IClustering_actionContext + Table_column_action() ITable_column_actionContext + Constraint_action() IConstraint_actionContext + Ext_table_column_action() IExt_table_column_actionContext + Search_optimization_action() ISearch_optimization_actionContext + SET() antlr.TerminalNode + Stage_file_format() IStage_file_formatContext + STAGE_COPY_OPTIONS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Copy_options() ICopy_optionsContext + RR_BRACKET() antlr.TerminalNode + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + CHANGE_TRACKING() antlr.TerminalNode + True_false() ITrue_falseContext + Default_ddl_collation() IDefault_ddl_collationContext + Comment_clause() IComment_clauseContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + DEFAULT_DDL_COLLATION_() antlr.TerminalNode + COMMENT() antlr.TerminalNode + ADD() antlr.TerminalNode + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AllACCESS() []antlr.TerminalNode + ACCESS(i int) antlr.TerminalNode + AllPOLICY() []antlr.TerminalNode + POLICY(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ON() antlr.TerminalNode + Column_list_in_parentheses() IColumn_list_in_parenthesesContext + DROP() antlr.TerminalNode + COMMA() antlr.TerminalNode + ALL() antlr.TerminalNode + POLICIES() antlr.TerminalNode + + // IsAlter_tableContext differentiates from other interfaces. + IsAlter_tableContext() +} + +type Alter_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tableContext() *Alter_tableContext { + var p = new(Alter_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_table + return p +} + +func InitEmptyAlter_tableContext(p *Alter_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_table +} + +func (*Alter_tableContext) IsAlter_tableContext() {} + +func NewAlter_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tableContext { + var p = new(Alter_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_table + + return p +} + +func (s *Alter_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tableContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Alter_tableContext) AllObject_name() []IObject_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_nameContext); ok { + len++ + } + } + + tst := make([]IObject_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_nameContext); ok { + tst[i] = t.(IObject_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Object_name(i int) IObject_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Alter_tableContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_tableContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_tableContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_tableContext) SWAP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSWAP, 0) +} + +func (s *Alter_tableContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Alter_tableContext) Clustering_action() IClustering_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClustering_actionContext) +} + +func (s *Alter_tableContext) Table_column_action() ITable_column_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_column_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_column_actionContext) +} + +func (s *Alter_tableContext) Constraint_action() IConstraint_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_actionContext) +} + +func (s *Alter_tableContext) Ext_table_column_action() IExt_table_column_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExt_table_column_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExt_table_column_actionContext) +} + +func (s *Alter_tableContext) Search_optimization_action() ISearch_optimization_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_optimization_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_optimization_actionContext) +} + +func (s *Alter_tableContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_tableContext) Stage_file_format() IStage_file_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStage_file_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStage_file_formatContext) +} + +func (s *Alter_tableContext) STAGE_COPY_OPTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE_COPY_OPTIONS, 0) +} + +func (s *Alter_tableContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_tableContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_tableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_tableContext) 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 *Alter_tableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_tableContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Alter_tableContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Alter_tableContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Alter_tableContext) CHANGE_TRACKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHANGE_TRACKING, 0) +} + +func (s *Alter_tableContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_tableContext) Default_ddl_collation() IDefault_ddl_collationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_ddl_collationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_ddl_collationContext) +} + +func (s *Alter_tableContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_tableContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_tableContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_tableContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_tableContext) DEFAULT_DDL_COLLATION_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_DDL_COLLATION_, 0) +} + +func (s *Alter_tableContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_tableContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_tableContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserROW) +} + +func (s *Alter_tableContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, i) +} + +func (s *Alter_tableContext) AllACCESS() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserACCESS) +} + +func (s *Alter_tableContext) ACCESS(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, i) +} + +func (s *Alter_tableContext) AllPOLICY() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserPOLICY) +} + +func (s *Alter_tableContext) POLICY(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, i) +} + +func (s *Alter_tableContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_tableContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Alter_tableContext) Column_list_in_parentheses() IColumn_list_in_parenthesesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_list_in_parenthesesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_list_in_parenthesesContext) +} + +func (s *Alter_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Alter_tableContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Alter_tableContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Alter_tableContext) POLICIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICIES, 0) +} + +func (s *Alter_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_table(s) + } +} + +func (s *Alter_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_table(s) + } +} + +func (s *Alter_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_table() (localctx IAlter_tableContext) { + localctx = NewAlter_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, SnowflakeParserRULE_alter_table) + var _la int + + p.SetState(4881) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 503, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4706) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4707) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4709) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 481, p.GetParserRuleContext()) == 1 { + { + p.SetState(4708) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4711) + p.Object_name() + } + { + p.SetState(4712) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4713) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4714) + p.Object_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4716) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4717) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4719) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 482, p.GetParserRuleContext()) == 1 { + { + p.SetState(4718) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4721) + p.Object_name() + } + { + p.SetState(4722) + p.Match(SnowflakeParserSWAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4723) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4724) + p.Object_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4726) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4727) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4729) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 483, p.GetParserRuleContext()) == 1 { + { + p.SetState(4728) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4731) + p.Object_name() + } + p.SetState(4735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 484, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4732) + p.Clustering_action() + } + + case 2: + { + p.SetState(4733) + p.Table_column_action() + } + + case 3: + { + p.SetState(4734) + p.Constraint_action() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4737) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4738) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4740) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 485, p.GetParserRuleContext()) == 1 { + { + p.SetState(4739) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4742) + p.Object_name() + } + { + p.SetState(4743) + p.Ext_table_column_action() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4745) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4746) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4748) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 486, p.GetParserRuleContext()) == 1 { + { + p.SetState(4747) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4750) + p.Object_name() + } + { + p.SetState(4751) + p.Search_optimization_action() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4753) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4754) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4756) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 487, p.GetParserRuleContext()) == 1 { + { + p.SetState(4755) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4758) + p.Object_name() + } + { + p.SetState(4759) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTAGE_FILE_FORMAT || _la == SnowflakeParserTYPE { + { + p.SetState(4760) + p.Stage_file_format() + } + + } + p.SetState(4769) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTAGE_COPY_OPTIONS { + { + p.SetState(4763) + p.Match(SnowflakeParserSTAGE_COPY_OPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4764) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4765) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4766) + p.Copy_options() + } + { + p.SetState(4767) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDATA_RETENTION_TIME_IN_DAYS { + { + p.SetState(4771) + p.Match(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4772) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4773) + p.Num() + } + + } + p.SetState(4779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS { + { + p.SetState(4776) + p.Match(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4777) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4778) + p.Num() + } + + } + p.SetState(4784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCHANGE_TRACKING { + { + p.SetState(4781) + p.Match(SnowflakeParserCHANGE_TRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4782) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4783) + p.True_false() + } + + } + p.SetState(4787) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDEFAULT_DDL_COLLATION_ { + { + p.SetState(4786) + p.Default_ddl_collation() + } + + } + p.SetState(4790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(4789) + p.Comment_clause() + } + + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4792) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4793) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4795) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 495, p.GetParserRuleContext()) == 1 { + { + p.SetState(4794) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4797) + p.Object_name() + } + { + p.SetState(4798) + p.Set_tags() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4800) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4801) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4803) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 496, p.GetParserRuleContext()) == 1 { + { + p.SetState(4802) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4805) + p.Object_name() + } + { + p.SetState(4806) + p.Unset_tags() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4808) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4809) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4811) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 497, p.GetParserRuleContext()) == 1 { + { + p.SetState(4810) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4813) + p.Object_name() + } + { + p.SetState(4814) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATA_RETENTION_TIME_IN_DAYS: + { + p.SetState(4815) + p.Match(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS: + { + p.SetState(4816) + p.Match(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserCHANGE_TRACKING: + { + p.SetState(4817) + p.Match(SnowflakeParserCHANGE_TRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDEFAULT_DDL_COLLATION_: + { + p.SetState(4818) + p.Match(SnowflakeParserDEFAULT_DDL_COLLATION_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserCOMMENT: + { + p.SetState(4819) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserEOF, SnowflakeParserSEMI: + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4823) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4824) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4826) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 499, p.GetParserRuleContext()) == 1 { + { + p.SetState(4825) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4828) + p.Object_name() + } + { + p.SetState(4829) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4830) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4831) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4832) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4833) + p.Id_() + } + { + p.SetState(4834) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4835) + p.Column_list_in_parentheses() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4837) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4838) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4840) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 500, p.GetParserRuleContext()) == 1 { + { + p.SetState(4839) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4842) + p.Object_name() + } + { + p.SetState(4843) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4844) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4845) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4846) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4847) + p.Id_() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(4849) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4850) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4852) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 501, p.GetParserRuleContext()) == 1 { + { + p.SetState(4851) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4854) + p.Object_name() + } + { + p.SetState(4855) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4856) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4857) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4858) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4859) + p.Id_() + } + { + p.SetState(4860) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4861) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4862) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4863) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4864) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4865) + p.Id_() + } + { + p.SetState(4866) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4867) + p.Column_list_in_parentheses() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(4869) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4870) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4872) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 502, p.GetParserRuleContext()) == 1 { + { + p.SetState(4871) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4874) + p.Object_name() + } + { + p.SetState(4875) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4876) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4877) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4878) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4879) + p.Match(SnowflakeParserPOLICIES) + 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 +} + +// IClustering_actionContext is an interface to support dynamic dispatch. +type IClustering_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTER() antlr.TerminalNode + BY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expr_list() IExpr_listContext + RR_BRACKET() antlr.TerminalNode + RECLUSTER() antlr.TerminalNode + MAX_SIZE() antlr.TerminalNode + EQ() antlr.TerminalNode + Num() INumContext + WHERE() antlr.TerminalNode + Expr() IExprContext + Resume_suspend() IResume_suspendContext + DROP() antlr.TerminalNode + CLUSTERING() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsClustering_actionContext differentiates from other interfaces. + IsClustering_actionContext() +} + +type Clustering_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_actionContext() *Clustering_actionContext { + var p = new(Clustering_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_clustering_action + return p +} + +func InitEmptyClustering_actionContext(p *Clustering_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_clustering_action +} + +func (*Clustering_actionContext) IsClustering_actionContext() {} + +func NewClustering_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_actionContext { + var p = new(Clustering_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_clustering_action + + return p +} + +func (s *Clustering_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_actionContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTER, 0) +} + +func (s *Clustering_actionContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Clustering_actionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Clustering_actionContext) 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 *Clustering_actionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Clustering_actionContext) RECLUSTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECLUSTER, 0) +} + +func (s *Clustering_actionContext) MAX_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_SIZE, 0) +} + +func (s *Clustering_actionContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Clustering_actionContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Clustering_actionContext) WHERE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHERE, 0) +} + +func (s *Clustering_actionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Clustering_actionContext) Resume_suspend() IResume_suspendContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResume_suspendContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResume_suspendContext) +} + +func (s *Clustering_actionContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Clustering_actionContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTERING, 0) +} + +func (s *Clustering_actionContext) KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEY, 0) +} + +func (s *Clustering_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterClustering_action(s) + } +} + +func (s *Clustering_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitClustering_action(s) + } +} + +func (s *Clustering_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitClustering_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Clustering_action() (localctx IClustering_actionContext) { + localctx = NewClustering_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, SnowflakeParserRULE_clustering_action) + var _la int + + p.SetState(4905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCLUSTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4883) + p.Match(SnowflakeParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4884) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4885) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4886) + p.Expr_list() + } + { + p.SetState(4887) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRECLUSTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4889) + p.Match(SnowflakeParserRECLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMAX_SIZE { + { + p.SetState(4890) + p.Match(SnowflakeParserMAX_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4891) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4892) + p.Num() + } + + } + p.SetState(4897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWHERE { + { + p.SetState(4895) + p.Match(SnowflakeParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4896) + p.expr(0) + } + + } + + case SnowflakeParserRESUME, SnowflakeParserSUSPEND: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4899) + p.Resume_suspend() + } + { + p.SetState(4900) + p.Match(SnowflakeParserRECLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4902) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4903) + p.Match(SnowflakeParserCLUSTERING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4904) + p.Match(SnowflakeParserKEY) + 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 +} + +// ITable_column_actionContext is an interface to support dynamic dispatch. +type ITable_column_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + Data_type() IData_typeContext + AllCOLUMN() []antlr.TerminalNode + COLUMN(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + Expr() IExprContext + Null_not_null() INull_not_nullContext + Inline_constraint() IInline_constraintContext + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + AUTOINCREMENT() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + START() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + WITH() antlr.TerminalNode + USING() antlr.TerminalNode + Column_list() IColumn_listContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Alter_modify() IAlter_modifyContext + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + Object_name() IObject_nameContext + DOT() antlr.TerminalNode + NEXTVAL() antlr.TerminalNode + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + TYPE() antlr.TerminalNode + DATA() antlr.TerminalNode + FORCE() antlr.TerminalNode + AllColumn_set_tags() []IColumn_set_tagsContext + Column_set_tags(i int) IColumn_set_tagsContext + AllColumn_unset_tags() []IColumn_unset_tagsContext + Column_unset_tags(i int) IColumn_unset_tagsContext + + // IsTable_column_actionContext differentiates from other interfaces. + IsTable_column_actionContext() +} + +type Table_column_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_column_actionContext() *Table_column_actionContext { + var p = new(Table_column_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_column_action + return p +} + +func InitEmptyTable_column_actionContext(p *Table_column_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_column_action +} + +func (*Table_column_actionContext) IsTable_column_actionContext() {} + +func NewTable_column_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_column_actionContext { + var p = new(Table_column_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_table_column_action + + return p +} + +func (s *Table_column_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_column_actionContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Table_column_actionContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Table_column_actionContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Table_column_actionContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Table_column_actionContext) AllCOLUMN() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOLUMN) +} + +func (s *Table_column_actionContext) COLUMN(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMN, i) +} + +func (s *Table_column_actionContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserDEFAULT) +} + +func (s *Table_column_actionContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT, i) +} + +func (s *Table_column_actionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Table_column_actionContext) Null_not_null() INull_not_nullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_not_nullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_not_nullContext) +} + +func (s *Table_column_actionContext) Inline_constraint() IInline_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *Table_column_actionContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Table_column_actionContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Table_column_actionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Table_column_actionContext) AUTOINCREMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTOINCREMENT, 0) +} + +func (s *Table_column_actionContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIDENTITY, 0) +} + +func (s *Table_column_actionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Table_column_actionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Table_column_actionContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Table_column_actionContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Table_column_actionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Table_column_actionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Table_column_actionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Table_column_actionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Table_column_actionContext) START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTART, 0) +} + +func (s *Table_column_actionContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINCREMENT, 0) +} + +func (s *Table_column_actionContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Table_column_actionContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *Table_column_actionContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Table_column_actionContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Table_column_actionContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Table_column_actionContext) Alter_modify() IAlter_modifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_modifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_modifyContext) +} + +func (s *Table_column_actionContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserDROP) +} + +func (s *Table_column_actionContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, i) +} + +func (s *Table_column_actionContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserSET) +} + +func (s *Table_column_actionContext) SET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, i) +} + +func (s *Table_column_actionContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Table_column_actionContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *Table_column_actionContext) NEXTVAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEXTVAL, 0) +} + +func (s *Table_column_actionContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Table_column_actionContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Table_column_actionContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Table_column_actionContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *Table_column_actionContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Table_column_actionContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Table_column_actionContext) DATA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA, 0) +} + +func (s *Table_column_actionContext) FORCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORCE, 0) +} + +func (s *Table_column_actionContext) AllColumn_set_tags() []IColumn_set_tagsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_set_tagsContext); ok { + len++ + } + } + + tst := make([]IColumn_set_tagsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_set_tagsContext); ok { + tst[i] = t.(IColumn_set_tagsContext) + i++ + } + } + + return tst +} + +func (s *Table_column_actionContext) Column_set_tags(i int) IColumn_set_tagsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_set_tagsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_set_tagsContext) +} + +func (s *Table_column_actionContext) AllColumn_unset_tags() []IColumn_unset_tagsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_unset_tagsContext); ok { + len++ + } + } + + tst := make([]IColumn_unset_tagsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_unset_tagsContext); ok { + tst[i] = t.(IColumn_unset_tagsContext) + i++ + } + } + + return tst +} + +func (s *Table_column_actionContext) Column_unset_tags(i int) IColumn_unset_tagsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_unset_tagsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_unset_tagsContext) +} + +func (s *Table_column_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_column_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_column_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTable_column_action(s) + } +} + +func (s *Table_column_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTable_column_action(s) + } +} + +func (s *Table_column_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTable_column_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Table_column_action() (localctx ITable_column_actionContext) { + localctx = NewTable_column_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, SnowflakeParserRULE_table_column_action) + var _la int + + p.SetState(5073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 532, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4907) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(4908) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4911) + p.Column_name() + } + { + p.SetState(4912) + p.Data_type() + } + p.SetState(4929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDEFAULT: + { + p.SetState(4913) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4914) + p.expr(0) + } + + case SnowflakeParserAUTOINCREMENT, SnowflakeParserIDENTITY: + { + p.SetState(4915) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAUTOINCREMENT || _la == SnowflakeParserIDENTITY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserLR_BRACKET: + { + p.SetState(4916) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4917) + p.Num() + } + { + p.SetState(4918) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4919) + p.Num() + } + { + p.SetState(4920) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTART: + { + p.SetState(4922) + p.Match(SnowflakeParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4923) + p.Num() + } + { + p.SetState(4924) + p.Match(SnowflakeParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4925) + p.Num() + } + + case SnowflakeParserEOF, SnowflakeParserCONSTRAINT, SnowflakeParserFOREIGN, SnowflakeParserMASKING, SnowflakeParserNOT, SnowflakeParserNULL_, SnowflakeParserPRIMARY, SnowflakeParserREFERENCES, SnowflakeParserUNIQUE, SnowflakeParserWITH, SnowflakeParserSEMI: + + default: + } + + case SnowflakeParserEOF, SnowflakeParserCONSTRAINT, SnowflakeParserFOREIGN, SnowflakeParserMASKING, SnowflakeParserNOT, SnowflakeParserNULL_, SnowflakeParserPRIMARY, SnowflakeParserREFERENCES, SnowflakeParserUNIQUE, SnowflakeParserWITH, SnowflakeParserSEMI: + + default: + } + p.SetState(4932) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 510, p.GetParserRuleContext()) == 1 { + { + p.SetState(4931) + p.Null_not_null() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCONSTRAINT || _la == SnowflakeParserFOREIGN || _la == SnowflakeParserNOT || _la == SnowflakeParserNULL_ || _la == SnowflakeParserPRIMARY || _la == SnowflakeParserREFERENCES || _la == SnowflakeParserUNIQUE { + { + p.SetState(4934) + p.Inline_constraint() + } + + } + p.SetState(4952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMASKING || _la == SnowflakeParserWITH { + p.SetState(4938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(4937) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4940) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4941) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4942) + p.Id_() + } + p.SetState(4950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(4943) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4944) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4945) + p.Column_name() + } + { + p.SetState(4946) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4947) + p.Column_list() + } + { + p.SetState(4948) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4954) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4955) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4956) + p.Column_name() + } + { + p.SetState(4957) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4958) + p.Column_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4960) + p.Alter_modify() + } + p.SetState(4962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(4961) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(4964) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4967) + p.Column_name() + } + { + p.SetState(4968) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4969) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4970) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(4971) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4974) + p.Column_name() + } + { + p.SetState(4975) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4976) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4977) + p.Object_name() + } + { + p.SetState(4978) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4979) + p.Match(SnowflakeParserNEXTVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4980) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(4981) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4984) + p.Column_name() + } + p.SetState(4993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserNOT, SnowflakeParserSET: + p.SetState(4986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET { + { + p.SetState(4985) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4988) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4989) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDROP: + { + p.SetState(4990) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4991) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4992) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4995) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(4996) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4999) + p.Column_name() + } + p.SetState(5005) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET || _la == SnowflakeParserTYPE { + p.SetState(5002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET { + { + p.SetState(5000) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5001) + p.Match(SnowflakeParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5004) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5007) + p.Data_type() + } + { + p.SetState(5008) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5009) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5012) + p.Column_name() + } + { + p.SetState(5013) + p.Comment_clause() + } + { + p.SetState(5014) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5015) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5018) + p.Column_name() + } + { + p.SetState(5019) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5020) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserRR_BRACKET { + { + p.SetState(5021) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5024) + p.Alter_modify() + } + { + p.SetState(5025) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5026) + p.Column_name() + } + { + p.SetState(5027) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5028) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5029) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5030) + p.Id_() + } + p.SetState(5038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(5031) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5032) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5033) + p.Column_name() + } + { + p.SetState(5034) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5035) + p.Column_list() + } + { + p.SetState(5036) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFORCE { + { + p.SetState(5040) + p.Match(SnowflakeParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5043) + p.Alter_modify() + } + { + p.SetState(5044) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5045) + p.Column_name() + } + { + p.SetState(5046) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5047) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5048) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5050) + p.Alter_modify() + } + { + p.SetState(5051) + p.Column_set_tags() + } + p.SetState(5056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5052) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5053) + p.Column_set_tags() + } + + p.SetState(5058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5059) + p.Alter_modify() + } + { + p.SetState(5060) + p.Column_unset_tags() + } + p.SetState(5065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5061) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5062) + p.Column_unset_tags() + } + + p.SetState(5067) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5068) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5069) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5072) + p.Column_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 +} + +// IInline_constraintContext is an interface to support dynamic dispatch. +type IInline_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNIQUE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + Null_not_null() INull_not_nullContext + CONSTRAINT() antlr.TerminalNode + Id_() IId_Context + Constraint_properties() IConstraint_propertiesContext + REFERENCES() antlr.TerminalNode + Object_name() IObject_nameContext + FOREIGN() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_name() IColumn_nameContext + RR_BRACKET() antlr.TerminalNode + + // IsInline_constraintContext differentiates from other interfaces. + IsInline_constraintContext() +} + +type Inline_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInline_constraintContext() *Inline_constraintContext { + var p = new(Inline_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_inline_constraint + return p +} + +func InitEmptyInline_constraintContext(p *Inline_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_inline_constraint +} + +func (*Inline_constraintContext) IsInline_constraintContext() {} + +func NewInline_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inline_constraintContext { + var p = new(Inline_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_inline_constraint + + return p +} + +func (s *Inline_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inline_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNIQUE, 0) +} + +func (s *Inline_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Inline_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEY, 0) +} + +func (s *Inline_constraintContext) Null_not_null() INull_not_nullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_not_nullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_not_nullContext) +} + +func (s *Inline_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONSTRAINT, 0) +} + +func (s *Inline_constraintContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Inline_constraintContext) Constraint_properties() IConstraint_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_propertiesContext) +} + +func (s *Inline_constraintContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFERENCES, 0) +} + +func (s *Inline_constraintContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Inline_constraintContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFOREIGN, 0) +} + +func (s *Inline_constraintContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Inline_constraintContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Inline_constraintContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Inline_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inline_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inline_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterInline_constraint(s) + } +} + +func (s *Inline_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitInline_constraint(s) + } +} + +func (s *Inline_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitInline_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Inline_constraint() (localctx IInline_constraintContext) { + localctx = NewInline_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, SnowflakeParserRULE_inline_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT || _la == SnowflakeParserNULL_ { + { + p.SetState(5075) + p.Null_not_null() + } + + } + p.SetState(5080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCONSTRAINT { + { + p.SetState(5078) + p.Match(SnowflakeParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5079) + p.Id_() + } + + } + p.SetState(5097) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserUNIQUE: + { + p.SetState(5082) + p.Match(SnowflakeParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserPRIMARY: + { + p.SetState(5083) + p.Match(SnowflakeParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5084) + p.Match(SnowflakeParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFOREIGN, SnowflakeParserREFERENCES: + p.SetState(5087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFOREIGN { + { + p.SetState(5085) + p.Match(SnowflakeParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5086) + p.Match(SnowflakeParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5089) + p.Match(SnowflakeParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5090) + p.Object_name() + } + p.SetState(5095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(5091) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5092) + p.Column_name() + } + { + p.SetState(5093) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(5100) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) == 1 { + { + p.SetState(5099) + p.Constraint_properties() + } + + } 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 +} + +// IConstraint_propertiesContext is an interface to support dynamic dispatch. +type IConstraint_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENFORCED() antlr.TerminalNode + NOT() antlr.TerminalNode + DEFERRABLE() antlr.TerminalNode + INITIALLY() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + MATCH() antlr.TerminalNode + FULL() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + NO() antlr.TerminalNode + ACTION() antlr.TerminalNode + DELETE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + RELY() antlr.TerminalNode + NORELY() antlr.TerminalNode + + // IsConstraint_propertiesContext differentiates from other interfaces. + IsConstraint_propertiesContext() +} + +type Constraint_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_propertiesContext() *Constraint_propertiesContext { + var p = new(Constraint_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_constraint_properties + return p +} + +func InitEmptyConstraint_propertiesContext(p *Constraint_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_constraint_properties +} + +func (*Constraint_propertiesContext) IsConstraint_propertiesContext() {} + +func NewConstraint_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_propertiesContext { + var p = new(Constraint_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_constraint_properties + + return p +} + +func (s *Constraint_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_propertiesContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENFORCED, 0) +} + +func (s *Constraint_propertiesContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *Constraint_propertiesContext) DEFERRABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFERRABLE, 0) +} + +func (s *Constraint_propertiesContext) INITIALLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINITIALLY, 0) +} + +func (s *Constraint_propertiesContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFERRED, 0) +} + +func (s *Constraint_propertiesContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMEDIATE, 0) +} + +func (s *Constraint_propertiesContext) MATCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCH, 0) +} + +func (s *Constraint_propertiesContext) FULL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFULL, 0) +} + +func (s *Constraint_propertiesContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARTIAL, 0) +} + +func (s *Constraint_propertiesContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIMPLE, 0) +} + +func (s *Constraint_propertiesContext) UPDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUPDATE, 0) +} + +func (s *Constraint_propertiesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCASCADE, 0) +} + +func (s *Constraint_propertiesContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Constraint_propertiesContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Constraint_propertiesContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT, 0) +} + +func (s *Constraint_propertiesContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESTRICT, 0) +} + +func (s *Constraint_propertiesContext) NO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNO, 0) +} + +func (s *Constraint_propertiesContext) ACTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACTION, 0) +} + +func (s *Constraint_propertiesContext) DELETE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELETE, 0) +} + +func (s *Constraint_propertiesContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *Constraint_propertiesContext) DISABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE, 0) +} + +func (s *Constraint_propertiesContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALIDATE, 0) +} + +func (s *Constraint_propertiesContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOVALIDATE, 0) +} + +func (s *Constraint_propertiesContext) RELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRELY, 0) +} + +func (s *Constraint_propertiesContext) NORELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNORELY, 0) +} + +func (s *Constraint_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterConstraint_properties(s) + } +} + +func (s *Constraint_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitConstraint_properties(s) + } +} + +func (s *Constraint_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitConstraint_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Constraint_properties() (localctx IConstraint_propertiesContext) { + localctx = NewConstraint_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, SnowflakeParserRULE_constraint_properties) + var _la int + + p.SetState(5142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 543, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(5102) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5105) + p.Match(SnowflakeParserENFORCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(5106) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5109) + p.Match(SnowflakeParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5110) + p.Match(SnowflakeParserINITIALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5111) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDEFERRED || _la == SnowflakeParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5112) + p.Match(SnowflakeParserMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5113) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserFULL || _la == SnowflakeParserPARTIAL || _la == SnowflakeParserSIMPLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5114) + p.Match(SnowflakeParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 541, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5115) + p.Match(SnowflakeParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5116) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5117) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5118) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5119) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(5120) + p.Match(SnowflakeParserRESTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(5121) + p.Match(SnowflakeParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5122) + p.Match(SnowflakeParserACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5125) + p.Match(SnowflakeParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 542, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5126) + p.Match(SnowflakeParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(5127) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5128) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(5129) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5130) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(5131) + p.Match(SnowflakeParserRESTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(5132) + p.Match(SnowflakeParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5133) + p.Match(SnowflakeParserACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5136) + p.Match(SnowflakeParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5137) + p.Match(SnowflakeParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5138) + p.Match(SnowflakeParserVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5139) + p.Match(SnowflakeParserNOVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5140) + p.Match(SnowflakeParserRELY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5141) + p.Match(SnowflakeParserNORELY) + 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 +} + +// IExt_table_column_actionContext is an interface to support dynamic dispatch. +type IExt_table_column_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + Data_type() IData_typeContext + AS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expr() IExprContext + RR_BRACKET() antlr.TerminalNode + COLUMN() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + DROP() antlr.TerminalNode + Column_list() IColumn_listContext + + // IsExt_table_column_actionContext differentiates from other interfaces. + IsExt_table_column_actionContext() +} + +type Ext_table_column_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExt_table_column_actionContext() *Ext_table_column_actionContext { + var p = new(Ext_table_column_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ext_table_column_action + return p +} + +func InitEmptyExt_table_column_actionContext(p *Ext_table_column_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ext_table_column_action +} + +func (*Ext_table_column_actionContext) IsExt_table_column_actionContext() {} + +func NewExt_table_column_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ext_table_column_actionContext { + var p = new(Ext_table_column_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_ext_table_column_action + + return p +} + +func (s *Ext_table_column_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ext_table_column_actionContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Ext_table_column_actionContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Ext_table_column_actionContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Ext_table_column_actionContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Ext_table_column_actionContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Ext_table_column_actionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Ext_table_column_actionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Ext_table_column_actionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Ext_table_column_actionContext) COLUMN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMN, 0) +} + +func (s *Ext_table_column_actionContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Ext_table_column_actionContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Ext_table_column_actionContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Ext_table_column_actionContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Ext_table_column_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ext_table_column_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ext_table_column_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExt_table_column_action(s) + } +} + +func (s *Ext_table_column_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExt_table_column_action(s) + } +} + +func (s *Ext_table_column_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExt_table_column_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Ext_table_column_action() (localctx IExt_table_column_actionContext) { + localctx = NewExt_table_column_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, SnowflakeParserRULE_ext_table_column_action) + var _la int + + p.SetState(5166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5144) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5145) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5148) + p.Column_name() + } + { + p.SetState(5149) + p.Data_type() + } + { + p.SetState(5150) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5151) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5152) + p.expr(0) + } + { + p.SetState(5153) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRENAME: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5155) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5156) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5157) + p.Column_name() + } + { + p.SetState(5158) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5159) + p.Column_name() + } + + case SnowflakeParserDROP: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5161) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5162) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5165) + p.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 +} + +// IConstraint_actionContext is an interface to support dynamic dispatch. +type IConstraint_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + Out_of_line_constraint() IOut_of_line_constraintContext + RENAME() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + TO() antlr.TerminalNode + Alter_modify() IAlter_modifyContext + Column_list_in_parentheses() IColumn_list_in_parenthesesContext + VALIDATE() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + RELY() antlr.TerminalNode + NORELY() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + ENFORCED() antlr.TerminalNode + NOT() antlr.TerminalNode + DROP() antlr.TerminalNode + Cascade_restrict() ICascade_restrictContext + + // IsConstraint_actionContext differentiates from other interfaces. + IsConstraint_actionContext() +} + +type Constraint_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_actionContext() *Constraint_actionContext { + var p = new(Constraint_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_constraint_action + return p +} + +func InitEmptyConstraint_actionContext(p *Constraint_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_constraint_action +} + +func (*Constraint_actionContext) IsConstraint_actionContext() {} + +func NewConstraint_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_actionContext { + var p = new(Constraint_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_constraint_action + + return p +} + +func (s *Constraint_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_actionContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Constraint_actionContext) Out_of_line_constraint() IOut_of_line_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Constraint_actionContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Constraint_actionContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONSTRAINT, 0) +} + +func (s *Constraint_actionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Constraint_actionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Constraint_actionContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Constraint_actionContext) Alter_modify() IAlter_modifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_modifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_modifyContext) +} + +func (s *Constraint_actionContext) Column_list_in_parentheses() IColumn_list_in_parenthesesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_list_in_parenthesesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_list_in_parenthesesContext) +} + +func (s *Constraint_actionContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALIDATE, 0) +} + +func (s *Constraint_actionContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOVALIDATE, 0) +} + +func (s *Constraint_actionContext) RELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRELY, 0) +} + +func (s *Constraint_actionContext) NORELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNORELY, 0) +} + +func (s *Constraint_actionContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Constraint_actionContext) KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEY, 0) +} + +func (s *Constraint_actionContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNIQUE, 0) +} + +func (s *Constraint_actionContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFOREIGN, 0) +} + +func (s *Constraint_actionContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENFORCED, 0) +} + +func (s *Constraint_actionContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *Constraint_actionContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Constraint_actionContext) Cascade_restrict() ICascade_restrictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICascade_restrictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICascade_restrictContext) +} + +func (s *Constraint_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterConstraint_action(s) + } +} + +func (s *Constraint_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitConstraint_action(s) + } +} + +func (s *Constraint_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitConstraint_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Constraint_action() (localctx IConstraint_actionContext) { + localctx = NewConstraint_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, SnowflakeParserRULE_constraint_action) + var _la int + + p.SetState(5210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5168) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5169) + p.Out_of_line_constraint() + } + + case SnowflakeParserRENAME: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5170) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5171) + p.Match(SnowflakeParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5172) + p.Id_() + } + { + p.SetState(5173) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5174) + p.Id_() + } + + case SnowflakeParserALTER, SnowflakeParserMODIFY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5176) + p.Alter_modify() + } + p.SetState(5184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCONSTRAINT: + { + p.SetState(5177) + p.Match(SnowflakeParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5178) + p.Id_() + } + + case SnowflakeParserPRIMARY: + { + p.SetState(5179) + p.Match(SnowflakeParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5180) + p.Match(SnowflakeParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUNIQUE: + { + p.SetState(5181) + p.Match(SnowflakeParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFOREIGN: + { + p.SetState(5182) + p.Match(SnowflakeParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5183) + p.Match(SnowflakeParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5186) + p.Column_list_in_parentheses() + } + p.SetState(5191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENFORCED || _la == SnowflakeParserNOT { + p.SetState(5188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(5187) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5190) + p.Match(SnowflakeParserENFORCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5193) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserNOVALIDATE || _la == SnowflakeParserVALIDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5194) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserNORELY || _la == SnowflakeParserRELY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5196) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCONSTRAINT: + { + p.SetState(5197) + p.Match(SnowflakeParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5198) + p.Id_() + } + + case SnowflakeParserPRIMARY: + { + p.SetState(5199) + p.Match(SnowflakeParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5200) + p.Match(SnowflakeParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUNIQUE: + { + p.SetState(5201) + p.Match(SnowflakeParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFOREIGN: + { + p.SetState(5202) + p.Match(SnowflakeParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5203) + p.Match(SnowflakeParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5206) + p.Column_list_in_parentheses() + } + p.SetState(5208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT { + { + p.SetState(5207) + p.Cascade_restrict() + } + + } + + 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 +} + +// ISearch_optimization_actionContext is an interface to support dynamic dispatch. +type ISearch_optimization_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + SEARCH() antlr.TerminalNode + OPTIMIZATION() antlr.TerminalNode + ON() antlr.TerminalNode + AllSearch_method_with_target() []ISearch_method_with_targetContext + Search_method_with_target(i int) ISearch_method_with_targetContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsSearch_optimization_actionContext differentiates from other interfaces. + IsSearch_optimization_actionContext() +} + +type Search_optimization_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySearch_optimization_actionContext() *Search_optimization_actionContext { + var p = new(Search_optimization_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_search_optimization_action + return p +} + +func InitEmptySearch_optimization_actionContext(p *Search_optimization_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_search_optimization_action +} + +func (*Search_optimization_actionContext) IsSearch_optimization_actionContext() {} + +func NewSearch_optimization_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_optimization_actionContext { + var p = new(Search_optimization_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_search_optimization_action + + return p +} + +func (s *Search_optimization_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Search_optimization_actionContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Search_optimization_actionContext) SEARCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEARCH, 0) +} + +func (s *Search_optimization_actionContext) OPTIMIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPTIMIZATION, 0) +} + +func (s *Search_optimization_actionContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Search_optimization_actionContext) AllSearch_method_with_target() []ISearch_method_with_targetContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISearch_method_with_targetContext); ok { + len++ + } + } + + tst := make([]ISearch_method_with_targetContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISearch_method_with_targetContext); ok { + tst[i] = t.(ISearch_method_with_targetContext) + i++ + } + } + + return tst +} + +func (s *Search_optimization_actionContext) Search_method_with_target(i int) ISearch_method_with_targetContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_method_with_targetContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISearch_method_with_targetContext) +} + +func (s *Search_optimization_actionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Search_optimization_actionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Search_optimization_actionContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Search_optimization_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Search_optimization_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Search_optimization_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSearch_optimization_action(s) + } +} + +func (s *Search_optimization_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSearch_optimization_action(s) + } +} + +func (s *Search_optimization_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSearch_optimization_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Search_optimization_action() (localctx ISearch_optimization_actionContext) { + localctx = NewSearch_optimization_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, SnowflakeParserRULE_search_optimization_action) + var _la int + + p.SetState(5240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5212) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5213) + p.Match(SnowflakeParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5214) + p.Match(SnowflakeParserOPTIMIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserON { + { + p.SetState(5215) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5216) + p.Search_method_with_target() + } + p.SetState(5221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5217) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5218) + p.Search_method_with_target() + } + + p.SetState(5223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case SnowflakeParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5226) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5227) + p.Match(SnowflakeParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5228) + p.Match(SnowflakeParserOPTIMIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserON { + { + p.SetState(5229) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5230) + p.Search_method_with_target() + } + p.SetState(5235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5231) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5232) + p.Search_method_with_target() + } + + p.SetState(5237) + 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 +} + +// ISearch_method_with_targetContext is an interface to support dynamic dispatch. +type ISearch_method_with_targetContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + EQUALITY() antlr.TerminalNode + SUBSTRING() antlr.TerminalNode + GEO() antlr.TerminalNode + STAR() antlr.TerminalNode + Expr() IExprContext + + // IsSearch_method_with_targetContext differentiates from other interfaces. + IsSearch_method_with_targetContext() +} + +type Search_method_with_targetContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySearch_method_with_targetContext() *Search_method_with_targetContext { + var p = new(Search_method_with_targetContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_search_method_with_target + return p +} + +func InitEmptySearch_method_with_targetContext(p *Search_method_with_targetContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_search_method_with_target +} + +func (*Search_method_with_targetContext) IsSearch_method_with_targetContext() {} + +func NewSearch_method_with_targetContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_method_with_targetContext { + var p = new(Search_method_with_targetContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_search_method_with_target + + return p +} + +func (s *Search_method_with_targetContext) GetParser() antlr.Parser { return s.parser } + +func (s *Search_method_with_targetContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Search_method_with_targetContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Search_method_with_targetContext) EQUALITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQUALITY, 0) +} + +func (s *Search_method_with_targetContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUBSTRING, 0) +} + +func (s *Search_method_with_targetContext) GEO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEO, 0) +} + +func (s *Search_method_with_targetContext) STAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAR, 0) +} + +func (s *Search_method_with_targetContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Search_method_with_targetContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Search_method_with_targetContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Search_method_with_targetContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSearch_method_with_target(s) + } +} + +func (s *Search_method_with_targetContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSearch_method_with_target(s) + } +} + +func (s *Search_method_with_targetContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSearch_method_with_target(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Search_method_with_target() (localctx ISearch_method_with_targetContext) { + localctx = NewSearch_method_with_targetContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, SnowflakeParserRULE_search_method_with_target) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5242) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserEQUALITY || _la == SnowflakeParserGEO || _la == SnowflakeParserSUBSTRING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5243) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTAR: + { + p.SetState(5244) + p.Match(SnowflakeParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAAD_PROVISIONER_Q, SnowflakeParserABORT, SnowflakeParserABORT_AFTER_WAIT, SnowflakeParserABORT_DETACHED_QUERY, SnowflakeParserABORT_STATEMENT, SnowflakeParserABSENT, SnowflakeParserABSOLUTE, SnowflakeParserACCESS, SnowflakeParserACCOUNTADMIN, SnowflakeParserACCOUNTS, SnowflakeParserACTION, SnowflakeParserACTIVE, SnowflakeParserADD, SnowflakeParserADMINISTER, SnowflakeParserADMIN_NAME, SnowflakeParserADMIN_PASSWORD, SnowflakeParserAES, SnowflakeParserAFTER, SnowflakeParserAGGREGATE, SnowflakeParserALERT, SnowflakeParserALERTS, SnowflakeParserALLOWED, SnowflakeParserALLOWED_ACCOUNTS, SnowflakeParserALLOWED_DATABASES, SnowflakeParserALLOWED_INTEGRATION_TYPES, SnowflakeParserALLOWED_IP_LIST, SnowflakeParserALLOWED_SHARES, SnowflakeParserALLOWED_VALUES, SnowflakeParserALLOW_CLIENT_MFA_CACHING, SnowflakeParserALLOW_CONNECTIONS, SnowflakeParserALLOW_DUPLICATE, SnowflakeParserALLOW_ID_TOKEN, SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, SnowflakeParserALLOW_OVERLAPPING_EXECUTION, SnowflakeParserALLOW_SINGLE_EVENT_LOSS, SnowflakeParserALWAYS, SnowflakeParserANONYMOUS, SnowflakeParserANSI_DEFAULTS, SnowflakeParserAPI, SnowflakeParserAPI_ALLOWED_PREFIXES, SnowflakeParserAPI_AWS_ROLE_ARN, SnowflakeParserAPI_BLOCKED_PREFIXES, SnowflakeParserAPI_INTEGRATION, SnowflakeParserAPI_KEY, SnowflakeParserAPI_PROVIDER, SnowflakeParserAPPEND, SnowflakeParserAPPEND_ONLY, SnowflakeParserAPPLICATION, SnowflakeParserAPPLY, SnowflakeParserAPP_NAME, SnowflakeParserASC, SnowflakeParserATTACH, SnowflakeParserAT_KEYWORD, SnowflakeParserAUTHORIZATION, SnowflakeParserAUTHORIZATIONS, SnowflakeParserAUTO, SnowflakeParserAUTO_Q, SnowflakeParserAUTOCOMMIT, SnowflakeParserAUTOCOMMIT_API_SUPPORTED, SnowflakeParserAUTOINCREMENT, SnowflakeParserAUTO_COMPRESS, SnowflakeParserAUTO_DETECT, SnowflakeParserAUTO_INGEST, SnowflakeParserAUTO_REFRESH, SnowflakeParserAUTO_RESUME, SnowflakeParserAUTO_SUSPEND, SnowflakeParserAVG, SnowflakeParserAVRO, SnowflakeParserAVRO_Q, SnowflakeParserAWS_KEY_ID, SnowflakeParserAWS_ROLE, SnowflakeParserAWS_SECRET_KEY, SnowflakeParserAWS_SNS, SnowflakeParserAWS_SNS_ROLE_ARN, SnowflakeParserAWS_SNS_TOPIC, SnowflakeParserAWS_SNS_TOPIC_ARN, SnowflakeParserAWS_TOKEN, SnowflakeParserAZURE, SnowflakeParserAZURE_AD_APPLICATION_ID, SnowflakeParserAZURE_EVENT_GRID, SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, SnowflakeParserAZURE_Q, SnowflakeParserAZURE_SAS_TOKEN, SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, SnowflakeParserAZURE_TENANT_ID, SnowflakeParserBEFORE, SnowflakeParserBEGIN, SnowflakeParserBERNOULLI, SnowflakeParserBINARY_AS_TEXT, SnowflakeParserBINARY_CHECKSUM, SnowflakeParserBINARY_FORMAT, SnowflakeParserBINARY_INPUT_FORMAT, SnowflakeParserBINARY_OUTPUT_FORMAT, SnowflakeParserBINDING, SnowflakeParserBLOCK, SnowflakeParserBLOCKED_IP_LIST, SnowflakeParserBLOCKED_ROLES_LIST, SnowflakeParserBODY, SnowflakeParserBOTH_Q, SnowflakeParserBROTLI, SnowflakeParserBUSINESS_CRITICAL, SnowflakeParserCACHE, SnowflakeParserCALL, SnowflakeParserCALLED, SnowflakeParserCALLER, SnowflakeParserCASCADE, SnowflakeParserCASE, SnowflakeParserCASE_INSENSITIVE, SnowflakeParserCASE_SENSITIVE, SnowflakeParserCAST, SnowflakeParserCATCH, SnowflakeParserCERTIFICATE, SnowflakeParserCHANGE, SnowflakeParserCHANGES, SnowflakeParserCHANGETABLE, SnowflakeParserCHANGE_RETENTION, SnowflakeParserCHANGE_TRACKING, SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserCHARINDEX, SnowflakeParserCHECKSUM, SnowflakeParserCHECKSUM_AGG, SnowflakeParserCHECK_EXPIRATION, SnowflakeParserCHECK_POLICY, SnowflakeParserCLASSIFIER_FUNCTION, SnowflakeParserCLEANUP, SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, SnowflakeParserCLIENT_MEMORY_LIMIT, SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, SnowflakeParserCLIENT_PREFETCH_THREADS, SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, SnowflakeParserCLONE, SnowflakeParserCLOSE, SnowflakeParserCLUSTER, SnowflakeParserCLUSTERED, SnowflakeParserCLUSTERING, SnowflakeParserCOALESCE, SnowflakeParserCOLLATE, SnowflakeParserCOLLECTION, SnowflakeParserCOLUMNS, SnowflakeParserCOL_LENGTH, SnowflakeParserCOL_NAME, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOMMITTED, SnowflakeParserCOMPRESS, SnowflakeParserCOMPRESSION, SnowflakeParserCONCAT, SnowflakeParserCONCAT_NULL_YIELDS_NULL, SnowflakeParserCONCAT_WS, SnowflakeParserCONDITION, SnowflakeParserCONFIGURATION, SnowflakeParserCONNECTIONS, SnowflakeParserCONTAINMENT, SnowflakeParserCONTAINS, SnowflakeParserCONTENT, SnowflakeParserCONTEXT, SnowflakeParserCONTEXT_HEADERS, SnowflakeParserCONTEXT_INFO, SnowflakeParserCONTINUE, SnowflakeParserCONTROL, SnowflakeParserCONVERSATION, SnowflakeParserCOOKIE, SnowflakeParserCOPY, SnowflakeParserCOPY_ONLY, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserCOUNT, SnowflakeParserCOUNT_BIG, SnowflakeParserCREDENTIALS, SnowflakeParserCREDIT_QUOTA, SnowflakeParserCSV, SnowflakeParserCSV_Q, SnowflakeParserCUBE, SnowflakeParserCUME_DIST, SnowflakeParserCURRENT_DATE, SnowflakeParserCURRENT_TIMESTAMP, SnowflakeParserCURSOR, SnowflakeParserCUSTOM, SnowflakeParserDAILY, SnowflakeParserDATA, SnowflakeParserDATABASES, SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, SnowflakeParserDATEADD, SnowflakeParserDATEDIFF, SnowflakeParserDATENAME, SnowflakeParserDATEPART, SnowflakeParserDATE_FORMAT, SnowflakeParserDATE_INPUT_FORMAT, SnowflakeParserDATE_OUTPUT_FORMAT, SnowflakeParserDATE_PART, SnowflakeParserDAYS, SnowflakeParserDAYS_TO_EXPIRY, SnowflakeParserDECLARE, SnowflakeParserDEFAULT, SnowflakeParserDEFAULT_DDL_COLLATION_, SnowflakeParserDEFAULT_NAMESPACE, SnowflakeParserDEFAULT_ROLE, SnowflakeParserDEFAULT_WAREHOUSE, SnowflakeParserDEFERRABLE, SnowflakeParserDEFERRED, SnowflakeParserDEFINE, SnowflakeParserDEFINITION, SnowflakeParserDEFLATE, SnowflakeParserDELEGATED, SnowflakeParserDELTA, SnowflakeParserDENSE_RANK, SnowflakeParserDESC, SnowflakeParserDESCRIBE, SnowflakeParserDIRECTION, SnowflakeParserDIRECTORY, SnowflakeParserDISABLE, SnowflakeParserDISABLED, SnowflakeParserDISABLE_AUTO_CONVERT, SnowflakeParserDISABLE_SNOWFLAKE_DATA, SnowflakeParserDISK, SnowflakeParserDISPLAY_NAME, SnowflakeParserDO, SnowflakeParserDOWNSTREAM, SnowflakeParserDOUBLE, SnowflakeParserDYNAMIC, SnowflakeParserECONOMY, SnowflakeParserEDITION, SnowflakeParserEMAIL, SnowflakeParserEMPTY_, SnowflakeParserEMPTY_FIELD_AS_NULL, SnowflakeParserENABLE, SnowflakeParserENABLED, SnowflakeParserENABLE_FOR_PRIVILEGE, SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, SnowflakeParserENABLE_OCTAL, SnowflakeParserENABLE_QUERY_ACCELERATION, SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, SnowflakeParserENCODING, SnowflakeParserENCRYPTION, SnowflakeParserEND, SnowflakeParserENDPOINT, SnowflakeParserEND_TIMESTAMP, SnowflakeParserENFORCED, SnowflakeParserENFORCE_LENGTH, SnowflakeParserENFORCE_SESSION_POLICY, SnowflakeParserENTERPRISE, SnowflakeParserEQUALITY, SnowflakeParserERROR_INTEGRATION, SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, SnowflakeParserESCAPE, SnowflakeParserESCAPE_UNENCLOSED_FIELD, SnowflakeParserEXCEPT, SnowflakeParserEXCHANGE, SnowflakeParserEXECUTE, SnowflakeParserEXECUTION, SnowflakeParserEXIST, SnowflakeParserEXIT, SnowflakeParserEXPAND, SnowflakeParserEXPIRY_DATE, SnowflakeParserEXPLAIN, SnowflakeParserEXPLICIT, SnowflakeParserEXTERNAL, SnowflakeParserEXTERNAL_OAUTH, SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ISSUER, SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, SnowflakeParserEXTERNAL_OAUTH_TYPE, SnowflakeParserEXTERNAL_STAGE, SnowflakeParserFAILOVER, SnowflakeParserFAILOVER_MODE, SnowflakeParserFAIL_OPERATION, SnowflakeParserFALSE, SnowflakeParserFETCH, SnowflakeParserFIELD_DELIMITER, SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, SnowflakeParserFILE, SnowflakeParserFILES, SnowflakeParserFILE_EXTENSION, SnowflakeParserFILE_FORMAT, SnowflakeParserFILTER, SnowflakeParserFIRST, SnowflakeParserFIRST_NAME, SnowflakeParserFLATTEN, SnowflakeParserFORCE, SnowflakeParserFOREIGN, SnowflakeParserFORMAT, SnowflakeParserFORMATS, SnowflakeParserFORMAT_NAME, SnowflakeParserFREQUENCY, SnowflakeParserFUNCTION, SnowflakeParserFUNCTIONS, SnowflakeParserFUTURE, SnowflakeParserGCP_PUBSUB, SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, SnowflakeParserGCP_PUBSUB_TOPIC_NAME, SnowflakeParserGCS, SnowflakeParserGENERIC_Q, SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, SnowflakeParserGEO, SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, SnowflakeParserGEOMETRY_OUTPUT_FORMAT, SnowflakeParserGET, SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, SnowflakeParserGLOBAL, SnowflakeParserGOOGLE_AUDIENCE, SnowflakeParserGOTO, SnowflakeParserGRANTS, SnowflakeParserGROUPING, SnowflakeParserGROUPING_ID, SnowflakeParserGROUPS, SnowflakeParserGZIP, SnowflakeParserHEADER, SnowflakeParserHEADERS, SnowflakeParserHEX, SnowflakeParserHIERARCHYID, SnowflakeParserHIGH, SnowflakeParserHISTORY, SnowflakeParserHOURS, SnowflakeParserIDENTITY, SnowflakeParserIF, SnowflakeParserIFF, SnowflakeParserIFNULL, SnowflakeParserIGNORE, SnowflakeParserIGNORE_CONSTRAINTS, SnowflakeParserIGNORE_DUP_KEY, SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, SnowflakeParserIGNORE_TRIGGERS, SnowflakeParserILIKE, SnowflakeParserIMMEDIATE, SnowflakeParserIMMEDIATELY, SnowflakeParserIMMUTABLE, SnowflakeParserIMPLICIT, SnowflakeParserIMPORT, SnowflakeParserIMPORTED, SnowflakeParserINDEX, SnowflakeParserINFORMATION, SnowflakeParserINIT, SnowflakeParserINITIALLY, SnowflakeParserINITIALLY_SUSPENDED, SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, SnowflakeParserINPUT, SnowflakeParserINSERT_ONLY, SnowflakeParserINSTEAD, SnowflakeParserINT, SnowflakeParserINTEGRATION, SnowflakeParserINTEGRATIONS, SnowflakeParserISNULL, SnowflakeParserISNUMERIC, SnowflakeParserISOLATION, SnowflakeParserJAVASCRIPT, SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, SnowflakeParserJDBC_USE_SESSION_TIMEZONE, SnowflakeParserJSON, SnowflakeParserJSON_Q, SnowflakeParserJSON_INDENT, SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, SnowflakeParserKB, SnowflakeParserKEEP, SnowflakeParserKEY, SnowflakeParserKEYS, SnowflakeParserKEYSET, SnowflakeParserKMS_KEY_ID, SnowflakeParserLAG, SnowflakeParserLANGUAGE, SnowflakeParserLARGE, SnowflakeParserLAST, SnowflakeParserLAST_NAME, SnowflakeParserLAST_QUERY_ID, SnowflakeParserLAST_VALUE, SnowflakeParserLEAD, SnowflakeParserLEFT, SnowflakeParserLEN, SnowflakeParserLENGTH, SnowflakeParserLEVEL, SnowflakeParserLIKE, SnowflakeParserLIMIT, SnowflakeParserLINENO, SnowflakeParserLIST, SnowflakeParserLISTENER_IP, SnowflakeParserLISTENER_PORT, SnowflakeParserLISTING, SnowflakeParserLOAD, SnowflakeParserLOCAL, SnowflakeParserLOCAL_SERVICE_NAME, SnowflakeParserLOCATION, SnowflakeParserLOCKS, SnowflakeParserLOCK_TIMEOUT, SnowflakeParserLOG, SnowflakeParserLOGIN, SnowflakeParserLOGIN_NAME, SnowflakeParserLOOKER, SnowflakeParserLOW, SnowflakeParserLOWER, SnowflakeParserLTRIM, SnowflakeParserLZO, SnowflakeParserMANAGE, SnowflakeParserMANAGED, SnowflakeParserMASK, SnowflakeParserMASKED, SnowflakeParserMASKING, SnowflakeParserMASTER, SnowflakeParserMASTER_KEY, SnowflakeParserMATCH, SnowflakeParserMATCHED, SnowflakeParserMATCHES, SnowflakeParserMATCH_BY_COLUMN_NAME, SnowflakeParserMATCH_RECOGNIZE, SnowflakeParserMATERIALIZED, SnowflakeParserMAX_BATCH_ROWS, SnowflakeParserMAX_CLUSTER_COUNT, SnowflakeParserMAX_CONCURRENCY_LEVEL, SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, SnowflakeParserMAX_SIZE, SnowflakeParserMEASURES, SnowflakeParserMEDIUM, SnowflakeParserMEMOIZABLE, SnowflakeParserMERGE, SnowflakeParserMIDDLE_NAME, SnowflakeParserMIN, SnowflakeParserMINS_TO_BYPASS_MFA, SnowflakeParserMINS_TO_UNLOCK, SnowflakeParserMINUS_, SnowflakeParserMINUTES, SnowflakeParserMIN_CLUSTER_COUNT, SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, SnowflakeParserMODE, SnowflakeParserMODIFIED_AFTER, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserMONITORS, SnowflakeParserMONTHLY, SnowflakeParserMOVE, SnowflakeParserMULTI_STATEMENT_COUNT, SnowflakeParserMULTI_USER, SnowflakeParserMUST_CHANGE, SnowflakeParserMUST_CHANGE_PASSWORD, SnowflakeParserNAME, SnowflakeParserNCHAR, SnowflakeParserNESTED_TRIGGERS, SnowflakeParserNETWORK, SnowflakeParserNETWORK_POLICY, SnowflakeParserNEVER, SnowflakeParserNEWID, SnowflakeParserNEWNAME, SnowflakeParserNEWSEQUENTIALID, SnowflakeParserNEW_ACCOUNT, SnowflakeParserNEW_BROKER, SnowflakeParserNEW_PASSWORD, SnowflakeParserNEXT, SnowflakeParserNEXTVAL, SnowflakeParserNO, SnowflakeParserNONE, SnowflakeParserNONE_Q, SnowflakeParserNORELY, SnowflakeParserNOT, SnowflakeParserNOTIFICATION, SnowflakeParserNOTIFICATIONS, SnowflakeParserNOTIFICATION_INTEGRATION, SnowflakeParserNOTIFICATION_PROVIDER, SnowflakeParserNOTIFY, SnowflakeParserNOTIFY_USERS, SnowflakeParserNOVALIDATE, SnowflakeParserNTILE, SnowflakeParserNULLIF, SnowflakeParserNULLS, SnowflakeParserNULL_, SnowflakeParserNULL_IF, SnowflakeParserNUMANODE, SnowflakeParserNUMBER, SnowflakeParserNUMERIC_ROUNDABORT, SnowflakeParserNVL, SnowflakeParserOAUTH, SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, SnowflakeParserOAUTH_CLIENT, SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, SnowflakeParserOAUTH_ENFORCE_PKCE, SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, SnowflakeParserOAUTH_REDIRECT_URI, SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, SnowflakeParserOAUTH_USE_SECONDARY_ROLES, SnowflakeParserOBJECT, SnowflakeParserOBJECT_Q, SnowflakeParserOBJECTS, SnowflakeParserOBJECT_TYPES, SnowflakeParserOFF, SnowflakeParserOFFSET, SnowflakeParserOFFSETS, SnowflakeParserOKTA, SnowflakeParserOKTA_PROVISIONER_Q, SnowflakeParserOKTA_Q, SnowflakeParserOLD, SnowflakeParserOLD_ACCOUNT, SnowflakeParserOLD_PASSWORD, SnowflakeParserOMIT, SnowflakeParserONE, SnowflakeParserONLINE, SnowflakeParserONLY, SnowflakeParserON_ERROR, SnowflakeParserON_FAILURE, SnowflakeParserOPEN, SnowflakeParserOPERATE, SnowflakeParserOPERATIONS, SnowflakeParserOPTIMIZATION, SnowflakeParserOPTION, SnowflakeParserORC, SnowflakeParserORC_Q, SnowflakeParserORGADMIN, SnowflakeParserOUTBOUND, SnowflakeParserOUTER, SnowflakeParserOVER, SnowflakeParserOVERRIDE, SnowflakeParserOVERWRITE, SnowflakeParserOWNER, SnowflakeParserOWNERSHIP, SnowflakeParserPAGE, SnowflakeParserPARALLEL, SnowflakeParserPARAMETERS, SnowflakeParserPARAM_NODE, SnowflakeParserPARQUET, SnowflakeParserPARQUET_Q, SnowflakeParserPARTIAL, SnowflakeParserPARTITION, SnowflakeParserPARTITIONS, SnowflakeParserPARTITION_TYPE, SnowflakeParserPASSWORD, SnowflakeParserPAST, SnowflakeParserPATH_, SnowflakeParserPATTERN, SnowflakeParserPER, SnowflakeParserPERCENT, SnowflakeParserPERCENTILE_CONT, SnowflakeParserPERCENTILE_DISC, SnowflakeParserPERCENT_RANK, SnowflakeParserPERIODIC_DATA_REKEYING, SnowflakeParserPERMISSION_SET, SnowflakeParserPERSISTED, SnowflakeParserPERSIST_SAMPLE_PERCENT, SnowflakeParserPING_FEDERATE, SnowflakeParserPIPE, SnowflakeParserPIPES, SnowflakeParserPIPE_EXECUTION_PAUSED, SnowflakeParserPIVOT, SnowflakeParserPLAN, SnowflakeParserPLATFORM, SnowflakeParserPOLICIES, SnowflakeParserPOLICY, SnowflakeParserPOOL, SnowflakeParserPORT, SnowflakeParserPRECEDING, SnowflakeParserPRECISION, SnowflakeParserPREDICATE, SnowflakeParserPREFIX, SnowflakeParserPRESERVE_SPACE, SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, SnowflakeParserPRIMARY, SnowflakeParserPRIMARY_ROLE, SnowflakeParserPRIOR, SnowflakeParserPRIORITY, SnowflakeParserPRIORITY_LEVEL, SnowflakeParserPRIVATE, SnowflakeParserPRIVATE_KEY, SnowflakeParserPRIVILEGES, SnowflakeParserPROC, SnowflakeParserPROCEDURE, SnowflakeParserPROCEDURES, SnowflakeParserPROCEDURE_NAME, SnowflakeParserPROCESS, SnowflakeParserPROFILE, SnowflakeParserPROPERTY, SnowflakeParserPROVIDER, SnowflakeParserPROVIDER_KEY_NAME, SnowflakeParserPUBLIC, SnowflakeParserPURGE, SnowflakeParserPUT, SnowflakeParserPYTHON, SnowflakeParserQUERIES, SnowflakeParserQUERY, SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, SnowflakeParserQUERY_TAG, SnowflakeParserQUEUE, SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, SnowflakeParserRANGE, SnowflakeParserRANK, SnowflakeParserRAW_DEFLATE, SnowflakeParserREAD, SnowflakeParserREADER, SnowflakeParserREADONLY, SnowflakeParserREADPAST, SnowflakeParserREADTEXT, SnowflakeParserREADWRITE, SnowflakeParserREAD_COMMITTED_SNAPSHOT, SnowflakeParserREAD_ONLY, SnowflakeParserREAD_ONLY_ROUTING_LIST, SnowflakeParserREAD_WRITE, SnowflakeParserREBUILD, SnowflakeParserRECEIVE, SnowflakeParserRECLUSTER, SnowflakeParserRECOMPILE, SnowflakeParserRECONFIGURE, SnowflakeParserRECORD_DELIMITER, SnowflakeParserRECOVERY, SnowflakeParserRECURSIVE, SnowflakeParserRECURSIVE_TRIGGERS, SnowflakeParserREFERENCES, SnowflakeParserREFERENCE_USAGE, SnowflakeParserREFRESH, SnowflakeParserREFRESH_ON_CREATE, SnowflakeParserREGION, SnowflakeParserREGIONS, SnowflakeParserREGION_GROUP, SnowflakeParserRELATIVE, SnowflakeParserRELY, SnowflakeParserREMOTE, SnowflakeParserREMOTE_PROC_TRANSACTIONS, SnowflakeParserREMOTE_SERVICE_NAME, SnowflakeParserREMOVE, SnowflakeParserRENAME, SnowflakeParserREPEATABLE, SnowflakeParserREPLACE, SnowflakeParserREPLACE_INVALID_CHARACTERS, SnowflakeParserREPLICA, SnowflakeParserREPLICATION, SnowflakeParserREPLICATION_SCHEDULE, SnowflakeParserREQUEST_TRANSLATOR, SnowflakeParserREQUIRED, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, SnowflakeParserRESET, SnowflakeParserRESOURCE, SnowflakeParserRESOURCES, SnowflakeParserRESOURCE_MONITOR, SnowflakeParserRESPONSE_TRANSLATOR, SnowflakeParserRESTART, SnowflakeParserRESTORE, SnowflakeParserRESTRICT, SnowflakeParserRESTRICTIONS, SnowflakeParserRESULT, SnowflakeParserRESUME, SnowflakeParserRETAINDAYS, SnowflakeParserRETURN, SnowflakeParserRETURNS, SnowflakeParserRETURN_ALL_ERRORS, SnowflakeParserRETURN_ERRORS, SnowflakeParserRETURN_FAILED_ONLY, SnowflakeParserRETURN_N_ROWS, SnowflakeParserRETURN_ROWS, SnowflakeParserREVERSE, SnowflakeParserREVERT, SnowflakeParserREWIND, SnowflakeParserRIGHT, SnowflakeParserROLE, SnowflakeParserROLES, SnowflakeParserROLLBACK, SnowflakeParserROLLUP, SnowflakeParserROOT, SnowflakeParserROWCOUNT, SnowflakeParserROWGUID, SnowflakeParserROWLOCK, SnowflakeParserROWS_PER_RESULTSET, SnowflakeParserROW_NUMBER, SnowflakeParserRSA_PUBLIC_KEY, SnowflakeParserRTRIM, SnowflakeParserRUN_AS_ROLE, SnowflakeParserSAFE, SnowflakeParserSAFETY, SnowflakeParserSAML_IDENTITY_PROVIDER, SnowflakeParserSAVE_OLD_URL, SnowflakeParserSCALING_POLICY, SnowflakeParserSCHEDULE, SnowflakeParserSCHEDULER, SnowflakeParserSCHEMAS, SnowflakeParserSCHEME, SnowflakeParserSCIM, SnowflakeParserSCIM_CLIENT, SnowflakeParserSCRIPT, SnowflakeParserSEARCH, SnowflakeParserSECONDARY, SnowflakeParserSECONDARY_ONLY, SnowflakeParserSECONDARY_ROLE, SnowflakeParserSECONDS, SnowflakeParserSECRET, SnowflakeParserSECURE, SnowflakeParserSECURITY, SnowflakeParserSECURITYADMIN, SnowflakeParserSEED, SnowflakeParserSELECT, SnowflakeParserSELF, SnowflakeParserSEQUENCE, SnowflakeParserSEQUENCES, SnowflakeParserSERVER, SnowflakeParserSERVICE, SnowflakeParserSESSION, SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, SnowflakeParserSESSION_POLICY, SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, SnowflakeParserSETS, SnowflakeParserSETUSER, SnowflakeParserSHARE, SnowflakeParserSHARED, SnowflakeParserSHARES, SnowflakeParserSHARE_RESTRICTIONS, SnowflakeParserSHOW, SnowflakeParserSHOWPLAN, SnowflakeParserSHOWPLAN_ALL, SnowflakeParserSHOWPLAN_TEXT, SnowflakeParserSHOWPLAN_XML, SnowflakeParserSHOW_INITIAL_ROWS, SnowflakeParserSIGNATURE, SnowflakeParserSIMPLE, SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, SnowflakeParserSINGLE_USER, SnowflakeParserSIZE, SnowflakeParserSIZE_LIMIT, SnowflakeParserSKIP_, SnowflakeParserSKIP_BLANK_LINES, SnowflakeParserSKIP_BYTE_ORDER_MARK, SnowflakeParserSKIP_FILE, SnowflakeParserSKIP_FILE_N, SnowflakeParserSKIP_HEADER, SnowflakeParserSMALL, SnowflakeParserSNAPPY, SnowflakeParserSNAPPY_COMPRESSION, SnowflakeParserSOUNDEX, SnowflakeParserSOURCE, SnowflakeParserSOURCE_COMPRESSION, SnowflakeParserSPACE_KEYWORD, SnowflakeParserSPARSE, SnowflakeParserSPECIFICATION, SnowflakeParserSPLIT, SnowflakeParserSPLIT_PART, SnowflakeParserSQL, SnowflakeParserSSO_LOGIN_PAGE, SnowflakeParserSTAGE, SnowflakeParserSTAGES, SnowflakeParserSTAGE_COPY_OPTIONS, SnowflakeParserSTAGE_FILE_FORMAT, SnowflakeParserSTANDARD, SnowflakeParserSTANDBY, SnowflakeParserSTARTED, SnowflakeParserSTARTS, SnowflakeParserSTART_DATE, SnowflakeParserSTART_TIMESTAMP, SnowflakeParserSTATE, SnowflakeParserSTATEMENT, SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, SnowflakeParserSTATIC, SnowflakeParserSTATISTICS, SnowflakeParserSTATS, SnowflakeParserSTATS_DATE, SnowflakeParserSTATS_STREAM, SnowflakeParserSTATUS, SnowflakeParserSTATUSONLY, SnowflakeParserSTDEV, SnowflakeParserSTDEVP, SnowflakeParserSTOP, SnowflakeParserSTOPLIST, SnowflakeParserSTOPPED, SnowflakeParserSTORAGE, SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, SnowflakeParserSTORAGE_AWS_OBJECT_ACL, SnowflakeParserSTORAGE_AWS_ROLE_ARN, SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, SnowflakeParserSTORAGE_INTEGRATION, SnowflakeParserSTORAGE_PROVIDER, SnowflakeParserSTR, SnowflakeParserSTREAM, SnowflakeParserSTREAMS, SnowflakeParserSTRICT, SnowflakeParserSTRICT_JSON_OUTPUT, SnowflakeParserSTRING_AGG, SnowflakeParserSTRING_ESCAPE, SnowflakeParserSTRIP_NULL_VALUES, SnowflakeParserSTRIP_OUTER_ARRAY, SnowflakeParserSTRIP_OUTER_ELEMENT, SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING, SnowflakeParserSUM, SnowflakeParserSUPPORTED, SnowflakeParserSUSPEND, SnowflakeParserSUSPENDED, SnowflakeParserSUSPEND_IMMEDIATE, SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, SnowflakeParserSWAP, SnowflakeParserSWITCH, SnowflakeParserSYNC_PASSWORD, SnowflakeParserSYSADMIN, SnowflakeParserSYSTEM, SnowflakeParserSYSTEM_USER, SnowflakeParserTABLEAU_DESKTOP, SnowflakeParserTABLEAU_SERVER, SnowflakeParserTABLES, SnowflakeParserTABLE_FORMAT, SnowflakeParserTABULAR, SnowflakeParserTAG, SnowflakeParserTAGS, SnowflakeParserTARGET, SnowflakeParserTARGET_LAG, SnowflakeParserTASK, SnowflakeParserTASKS, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserTERSE, SnowflakeParserTEXTSIZE, SnowflakeParserTIES, SnowflakeParserTIME, SnowflakeParserTIMEADD, SnowflakeParserTIMEDIFF, SnowflakeParserTIMEOUT, SnowflakeParserTIMER, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_FORMAT, SnowflakeParserTIMESTAMP_INPUT_FORMAT, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_TYPE_MAPPING, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMPADD, SnowflakeParserTIMESTAMPDIFF, SnowflakeParserTIMEZONE, SnowflakeParserTIME_FORMAT, SnowflakeParserTIME_INPUT_FORMAT, SnowflakeParserTIME_OUTPUT_FORMAT, SnowflakeParserTO_BOOLEAN, SnowflakeParserTO_DATE, SnowflakeParserTOP, SnowflakeParserTORN_PAGE_DETECTION, SnowflakeParserTRACKING, SnowflakeParserTRACK_CAUSALITY, SnowflakeParserTRAN, SnowflakeParserTRANSACTION, SnowflakeParserTRANSACTIONS, SnowflakeParserTRANSACTION_ABORT_ON_ERROR, SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, SnowflakeParserTRANSACTION_ID, SnowflakeParserTRANSFORM_NOISE_WORDS, SnowflakeParserTRANSIENT, SnowflakeParserTRANSLATE, SnowflakeParserTRIGGERS, SnowflakeParserTRIM, SnowflakeParserTRIM_SPACE, SnowflakeParserTRIPLE_DES, SnowflakeParserTRUE, SnowflakeParserTRUNCATE, SnowflakeParserTRUNCATECOLUMNS, SnowflakeParserTRUSTWORTHY, SnowflakeParserTRY, SnowflakeParserTRY_CAST, SnowflakeParserTSEQUAL, SnowflakeParserTSQL, SnowflakeParserTWO_DIGIT_CENTURY_START, SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, SnowflakeParserTYPE, SnowflakeParserTYPEPROPERTY, SnowflakeParserTYPE_ID, SnowflakeParserTYPE_NAME, SnowflakeParserTYPE_WARNING, SnowflakeParserUN, SnowflakeParserUNBOUNDED, SnowflakeParserUNCHECKED, SnowflakeParserUNCOMMITTED, SnowflakeParserUNDROP, SnowflakeParserUNICODE, SnowflakeParserUNKNOWN, SnowflakeParserUNLIMITED, SnowflakeParserUNLOCK, SnowflakeParserUNMASK, SnowflakeParserUNMATCHED, SnowflakeParserUNPIVOT, SnowflakeParserUNSAFE, SnowflakeParserUNSET, SnowflakeParserUNSUPPORTED_DDL_ACTION, SnowflakeParserUOW, SnowflakeParserUPDLOCK, SnowflakeParserUPPER, SnowflakeParserURL, SnowflakeParserUSAGE, SnowflakeParserUSE, SnowflakeParserUSED, SnowflakeParserUSER, SnowflakeParserUSERADMIN, SnowflakeParserUSERS, SnowflakeParserUSER_SPECIFIED, SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, SnowflakeParserUSER_TASK_TIMEOUT_MS, SnowflakeParserUSE_ANY_ROLE, SnowflakeParserUSE_CACHED_RESULT, SnowflakeParserVALIDATE, SnowflakeParserVALIDATION, SnowflakeParserVALIDATION_MODE, SnowflakeParserVALID_XML, SnowflakeParserVALUE, SnowflakeParserVAR, SnowflakeParserVARIABLES, SnowflakeParserVARP, SnowflakeParserVARYING, SnowflakeParserVERSION, SnowflakeParserVIEWS, SnowflakeParserVIEW_METADATA, SnowflakeParserVISIBILITY, SnowflakeParserVOLATILE, SnowflakeParserWAIT, SnowflakeParserWAREHOUSE, SnowflakeParserWAREHOUSES, SnowflakeParserWAREHOUSE_SIZE, SnowflakeParserWEEKLY, SnowflakeParserWEEK_OF_YEAR_POLICY, SnowflakeParserWEEK_START, SnowflakeParserWELL_FORMED_XML, SnowflakeParserWITH, SnowflakeParserWITHIN, SnowflakeParserWITHOUT, SnowflakeParserWITHOUT_ARRAY_WRAPPER, SnowflakeParserWORK, SnowflakeParserWORKLOAD, SnowflakeParserWRITE, SnowflakeParserXLARGE, SnowflakeParserXLOCK, SnowflakeParserXML, SnowflakeParserXML_Q, SnowflakeParserXSMALL, SnowflakeParserXXLARGE, SnowflakeParserXXXLARGE, SnowflakeParserYEARLY, SnowflakeParserZSTD, SnowflakeParserARRAY, SnowflakeParserARRAY_Q, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserCHAR_VARYING, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNCHAR_VARYING, SnowflakeParserNUMERIC, SnowflakeParserNVARCHAR, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT, SnowflakeParserLISTAGG, SnowflakeParserDUMMY, SnowflakeParserDOUBLE_QUOTE_ID, SnowflakeParserDOUBLE_QUOTE_BLANK, SnowflakeParserID, SnowflakeParserID2, SnowflakeParserSTRING, SnowflakeParserDECIMAL, SnowflakeParserFLOAT, SnowflakeParserREAL, SnowflakeParserDOT, SnowflakeParserAT_Q, SnowflakeParserLR_BRACKET, SnowflakeParserLSB, SnowflakeParserLCB, SnowflakeParserPLUS, SnowflakeParserMINUS: + { + p.SetState(5245) + p.expr(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5248) + p.Match(SnowflakeParserRR_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 +} + +// IAlter_table_alter_columnContext is an interface to support dynamic dispatch. +type IAlter_table_alter_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + Alter_modify() IAlter_modifyContext + LR_BRACKET() antlr.TerminalNode + Alter_column_decl_list() IAlter_column_decl_listContext + RR_BRACKET() antlr.TerminalNode + COLUMN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + SET() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + USING() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Column_list() IColumn_listContext + FORCE() antlr.TerminalNode + UNSET() antlr.TerminalNode + AllColumn_set_tags() []IColumn_set_tagsContext + Column_set_tags(i int) IColumn_set_tagsContext + AllColumn_unset_tags() []IColumn_unset_tagsContext + Column_unset_tags(i int) IColumn_unset_tagsContext + + // IsAlter_table_alter_columnContext differentiates from other interfaces. + IsAlter_table_alter_columnContext() +} + +type Alter_table_alter_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_alter_columnContext() *Alter_table_alter_columnContext { + var p = new(Alter_table_alter_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_table_alter_column + return p +} + +func InitEmptyAlter_table_alter_columnContext(p *Alter_table_alter_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_table_alter_column +} + +func (*Alter_table_alter_columnContext) IsAlter_table_alter_columnContext() {} + +func NewAlter_table_alter_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_alter_columnContext { + var p = new(Alter_table_alter_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_table_alter_column + + return p +} + +func (s *Alter_table_alter_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_alter_columnContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_table_alter_columnContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Alter_table_alter_columnContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Alter_table_alter_columnContext) Alter_modify() IAlter_modifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_modifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_modifyContext) +} + +func (s *Alter_table_alter_columnContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_table_alter_columnContext) Alter_column_decl_list() IAlter_column_decl_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_column_decl_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_column_decl_listContext) +} + +func (s *Alter_table_alter_columnContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_table_alter_columnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMN, 0) +} + +func (s *Alter_table_alter_columnContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_alter_columnContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Alter_table_alter_columnContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_table_alter_columnContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Alter_table_alter_columnContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Alter_table_alter_columnContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_table_alter_columnContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *Alter_table_alter_columnContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_table_alter_columnContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_table_alter_columnContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Alter_table_alter_columnContext) FORCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORCE, 0) +} + +func (s *Alter_table_alter_columnContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_table_alter_columnContext) AllColumn_set_tags() []IColumn_set_tagsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_set_tagsContext); ok { + len++ + } + } + + tst := make([]IColumn_set_tagsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_set_tagsContext); ok { + tst[i] = t.(IColumn_set_tagsContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_alter_columnContext) Column_set_tags(i int) IColumn_set_tagsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_set_tagsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_set_tagsContext) +} + +func (s *Alter_table_alter_columnContext) AllColumn_unset_tags() []IColumn_unset_tagsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_unset_tagsContext); ok { + len++ + } + } + + tst := make([]IColumn_unset_tagsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_unset_tagsContext); ok { + tst[i] = t.(IColumn_unset_tagsContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_alter_columnContext) Column_unset_tags(i int) IColumn_unset_tagsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_unset_tagsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_unset_tagsContext) +} + +func (s *Alter_table_alter_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_alter_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_alter_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_table_alter_column(s) + } +} + +func (s *Alter_table_alter_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_table_alter_column(s) + } +} + +func (s *Alter_table_alter_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_table_alter_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_table_alter_column() (localctx IAlter_table_alter_columnContext) { + localctx = NewAlter_table_alter_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, SnowflakeParserRULE_alter_table_alter_column) + var _la int + + p.SetState(5317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5250) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5251) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5252) + p.Object_name() + } + { + p.SetState(5253) + p.Alter_modify() + } + p.SetState(5259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserLR_BRACKET: + { + p.SetState(5254) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5255) + p.Alter_column_decl_list() + } + { + p.SetState(5256) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAAD_PROVISIONER_Q, SnowflakeParserABORT, SnowflakeParserABORT_AFTER_WAIT, SnowflakeParserABORT_DETACHED_QUERY, SnowflakeParserABORT_STATEMENT, SnowflakeParserABSENT, SnowflakeParserABSOLUTE, SnowflakeParserACCESS, SnowflakeParserACCOUNTADMIN, SnowflakeParserACCOUNTS, SnowflakeParserACTION, SnowflakeParserACTIVE, SnowflakeParserADD, SnowflakeParserADMINISTER, SnowflakeParserADMIN_NAME, SnowflakeParserADMIN_PASSWORD, SnowflakeParserAES, SnowflakeParserAFTER, SnowflakeParserAGGREGATE, SnowflakeParserALERT, SnowflakeParserALERTS, SnowflakeParserALLOWED, SnowflakeParserALLOWED_ACCOUNTS, SnowflakeParserALLOWED_DATABASES, SnowflakeParserALLOWED_INTEGRATION_TYPES, SnowflakeParserALLOWED_IP_LIST, SnowflakeParserALLOWED_SHARES, SnowflakeParserALLOWED_VALUES, SnowflakeParserALLOW_CLIENT_MFA_CACHING, SnowflakeParserALLOW_CONNECTIONS, SnowflakeParserALLOW_DUPLICATE, SnowflakeParserALLOW_ID_TOKEN, SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, SnowflakeParserALLOW_OVERLAPPING_EXECUTION, SnowflakeParserALLOW_SINGLE_EVENT_LOSS, SnowflakeParserALWAYS, SnowflakeParserANONYMOUS, SnowflakeParserANSI_DEFAULTS, SnowflakeParserAPI, SnowflakeParserAPI_ALLOWED_PREFIXES, SnowflakeParserAPI_AWS_ROLE_ARN, SnowflakeParserAPI_BLOCKED_PREFIXES, SnowflakeParserAPI_INTEGRATION, SnowflakeParserAPI_KEY, SnowflakeParserAPI_PROVIDER, SnowflakeParserAPPEND, SnowflakeParserAPPEND_ONLY, SnowflakeParserAPPLICATION, SnowflakeParserAPPLY, SnowflakeParserAPP_NAME, SnowflakeParserASC, SnowflakeParserATTACH, SnowflakeParserAT_KEYWORD, SnowflakeParserAUTHORIZATION, SnowflakeParserAUTHORIZATIONS, SnowflakeParserAUTO, SnowflakeParserAUTO_Q, SnowflakeParserAUTOCOMMIT, SnowflakeParserAUTOCOMMIT_API_SUPPORTED, SnowflakeParserAUTOINCREMENT, SnowflakeParserAUTO_COMPRESS, SnowflakeParserAUTO_DETECT, SnowflakeParserAUTO_INGEST, SnowflakeParserAUTO_REFRESH, SnowflakeParserAUTO_RESUME, SnowflakeParserAUTO_SUSPEND, SnowflakeParserAVG, SnowflakeParserAVRO, SnowflakeParserAVRO_Q, SnowflakeParserAWS_KEY_ID, SnowflakeParserAWS_ROLE, SnowflakeParserAWS_SECRET_KEY, SnowflakeParserAWS_SNS, SnowflakeParserAWS_SNS_ROLE_ARN, SnowflakeParserAWS_SNS_TOPIC, SnowflakeParserAWS_SNS_TOPIC_ARN, SnowflakeParserAWS_TOKEN, SnowflakeParserAZURE, SnowflakeParserAZURE_AD_APPLICATION_ID, SnowflakeParserAZURE_EVENT_GRID, SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, SnowflakeParserAZURE_Q, SnowflakeParserAZURE_SAS_TOKEN, SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, SnowflakeParserAZURE_TENANT_ID, SnowflakeParserBEFORE, SnowflakeParserBEGIN, SnowflakeParserBERNOULLI, SnowflakeParserBINARY_AS_TEXT, SnowflakeParserBINARY_CHECKSUM, SnowflakeParserBINARY_FORMAT, SnowflakeParserBINARY_INPUT_FORMAT, SnowflakeParserBINARY_OUTPUT_FORMAT, SnowflakeParserBINDING, SnowflakeParserBLOCK, SnowflakeParserBLOCKED_IP_LIST, SnowflakeParserBLOCKED_ROLES_LIST, SnowflakeParserBODY, SnowflakeParserBOTH_Q, SnowflakeParserBROTLI, SnowflakeParserBUSINESS_CRITICAL, SnowflakeParserCACHE, SnowflakeParserCALL, SnowflakeParserCALLED, SnowflakeParserCALLER, SnowflakeParserCASCADE, SnowflakeParserCASE_INSENSITIVE, SnowflakeParserCASE_SENSITIVE, SnowflakeParserCATCH, SnowflakeParserCERTIFICATE, SnowflakeParserCHANGE, SnowflakeParserCHANGES, SnowflakeParserCHANGETABLE, SnowflakeParserCHANGE_RETENTION, SnowflakeParserCHANGE_TRACKING, SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserCHARINDEX, SnowflakeParserCHECKSUM, SnowflakeParserCHECKSUM_AGG, SnowflakeParserCHECK_EXPIRATION, SnowflakeParserCHECK_POLICY, SnowflakeParserCLASSIFIER_FUNCTION, SnowflakeParserCLEANUP, SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, SnowflakeParserCLIENT_MEMORY_LIMIT, SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, SnowflakeParserCLIENT_PREFETCH_THREADS, SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, SnowflakeParserCLONE, SnowflakeParserCLOSE, SnowflakeParserCLUSTER, SnowflakeParserCLUSTERED, SnowflakeParserCLUSTERING, SnowflakeParserCOALESCE, SnowflakeParserCOLLATE, SnowflakeParserCOLLECTION, SnowflakeParserCOLUMN, SnowflakeParserCOLUMNS, SnowflakeParserCOL_LENGTH, SnowflakeParserCOL_NAME, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOMMITTED, SnowflakeParserCOMPRESS, SnowflakeParserCOMPRESSION, SnowflakeParserCONCAT, SnowflakeParserCONCAT_NULL_YIELDS_NULL, SnowflakeParserCONCAT_WS, SnowflakeParserCONDITION, SnowflakeParserCONFIGURATION, SnowflakeParserCONNECTIONS, SnowflakeParserCONTAINMENT, SnowflakeParserCONTAINS, SnowflakeParserCONTENT, SnowflakeParserCONTEXT, SnowflakeParserCONTEXT_HEADERS, SnowflakeParserCONTEXT_INFO, SnowflakeParserCONTINUE, SnowflakeParserCONTROL, SnowflakeParserCONVERSATION, SnowflakeParserCOOKIE, SnowflakeParserCOPY, SnowflakeParserCOPY_ONLY, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserCOUNT, SnowflakeParserCOUNT_BIG, SnowflakeParserCREDENTIALS, SnowflakeParserCREDIT_QUOTA, SnowflakeParserCSV, SnowflakeParserCSV_Q, SnowflakeParserCUBE, SnowflakeParserCUME_DIST, SnowflakeParserCURRENT_DATE, SnowflakeParserCURRENT_TIMESTAMP, SnowflakeParserCURSOR, SnowflakeParserCUSTOM, SnowflakeParserDAILY, SnowflakeParserDATA, SnowflakeParserDATABASES, SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, SnowflakeParserDATEADD, SnowflakeParserDATEDIFF, SnowflakeParserDATENAME, SnowflakeParserDATEPART, SnowflakeParserDATE_FORMAT, SnowflakeParserDATE_INPUT_FORMAT, SnowflakeParserDATE_OUTPUT_FORMAT, SnowflakeParserDATE_PART, SnowflakeParserDAYS, SnowflakeParserDAYS_TO_EXPIRY, SnowflakeParserDECLARE, SnowflakeParserDEFAULT, SnowflakeParserDEFAULT_DDL_COLLATION_, SnowflakeParserDEFAULT_NAMESPACE, SnowflakeParserDEFAULT_ROLE, SnowflakeParserDEFAULT_WAREHOUSE, SnowflakeParserDEFERRABLE, SnowflakeParserDEFERRED, SnowflakeParserDEFINE, SnowflakeParserDEFINITION, SnowflakeParserDEFLATE, SnowflakeParserDELEGATED, SnowflakeParserDELTA, SnowflakeParserDENSE_RANK, SnowflakeParserDESC, SnowflakeParserDESCRIBE, SnowflakeParserDIRECTION, SnowflakeParserDIRECTORY, SnowflakeParserDISABLE, SnowflakeParserDISABLED, SnowflakeParserDISABLE_AUTO_CONVERT, SnowflakeParserDISABLE_SNOWFLAKE_DATA, SnowflakeParserDISK, SnowflakeParserDISPLAY_NAME, SnowflakeParserDO, SnowflakeParserDOWNSTREAM, SnowflakeParserDOUBLE, SnowflakeParserDYNAMIC, SnowflakeParserECONOMY, SnowflakeParserEDITION, SnowflakeParserEMAIL, SnowflakeParserEMPTY_, SnowflakeParserEMPTY_FIELD_AS_NULL, SnowflakeParserENABLE, SnowflakeParserENABLED, SnowflakeParserENABLE_FOR_PRIVILEGE, SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, SnowflakeParserENABLE_OCTAL, SnowflakeParserENABLE_QUERY_ACCELERATION, SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, SnowflakeParserENCODING, SnowflakeParserENCRYPTION, SnowflakeParserEND, SnowflakeParserENDPOINT, SnowflakeParserEND_TIMESTAMP, SnowflakeParserENFORCED, SnowflakeParserENFORCE_LENGTH, SnowflakeParserENFORCE_SESSION_POLICY, SnowflakeParserENTERPRISE, SnowflakeParserEQUALITY, SnowflakeParserERROR_INTEGRATION, SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, SnowflakeParserESCAPE, SnowflakeParserESCAPE_UNENCLOSED_FIELD, SnowflakeParserEXCEPT, SnowflakeParserEXCHANGE, SnowflakeParserEXECUTE, SnowflakeParserEXECUTION, SnowflakeParserEXIST, SnowflakeParserEXIT, SnowflakeParserEXPAND, SnowflakeParserEXPIRY_DATE, SnowflakeParserEXPLAIN, SnowflakeParserEXPLICIT, SnowflakeParserEXTERNAL, SnowflakeParserEXTERNAL_OAUTH, SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ISSUER, SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, SnowflakeParserEXTERNAL_OAUTH_TYPE, SnowflakeParserEXTERNAL_STAGE, SnowflakeParserFAILOVER, SnowflakeParserFAILOVER_MODE, SnowflakeParserFAIL_OPERATION, SnowflakeParserFETCH, SnowflakeParserFIELD_DELIMITER, SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, SnowflakeParserFILE, SnowflakeParserFILES, SnowflakeParserFILE_EXTENSION, SnowflakeParserFILE_FORMAT, SnowflakeParserFILTER, SnowflakeParserFIRST, SnowflakeParserFIRST_NAME, SnowflakeParserFLATTEN, SnowflakeParserFORCE, SnowflakeParserFOREIGN, SnowflakeParserFORMAT, SnowflakeParserFORMATS, SnowflakeParserFORMAT_NAME, SnowflakeParserFREQUENCY, SnowflakeParserFUNCTION, SnowflakeParserFUNCTIONS, SnowflakeParserFUTURE, SnowflakeParserGCP_PUBSUB, SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, SnowflakeParserGCP_PUBSUB_TOPIC_NAME, SnowflakeParserGCS, SnowflakeParserGENERIC_Q, SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, SnowflakeParserGEO, SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, SnowflakeParserGEOMETRY_OUTPUT_FORMAT, SnowflakeParserGET, SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, SnowflakeParserGLOBAL, SnowflakeParserGOOGLE_AUDIENCE, SnowflakeParserGOTO, SnowflakeParserGRANTS, SnowflakeParserGROUPING, SnowflakeParserGROUPING_ID, SnowflakeParserGROUPS, SnowflakeParserGZIP, SnowflakeParserHEADER, SnowflakeParserHEADERS, SnowflakeParserHEX, SnowflakeParserHIERARCHYID, SnowflakeParserHIGH, SnowflakeParserHISTORY, SnowflakeParserHOURS, SnowflakeParserIDENTITY, SnowflakeParserIF, SnowflakeParserIFF, SnowflakeParserIFNULL, SnowflakeParserIGNORE, SnowflakeParserIGNORE_CONSTRAINTS, SnowflakeParserIGNORE_DUP_KEY, SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, SnowflakeParserIGNORE_TRIGGERS, SnowflakeParserIMMEDIATE, SnowflakeParserIMMEDIATELY, SnowflakeParserIMMUTABLE, SnowflakeParserIMPLICIT, SnowflakeParserIMPORT, SnowflakeParserIMPORTED, SnowflakeParserINDEX, SnowflakeParserINFORMATION, SnowflakeParserINIT, SnowflakeParserINITIALLY, SnowflakeParserINITIALLY_SUSPENDED, SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, SnowflakeParserINPUT, SnowflakeParserINSERT_ONLY, SnowflakeParserINSTEAD, SnowflakeParserINT, SnowflakeParserINTEGRATION, SnowflakeParserINTEGRATIONS, SnowflakeParserISNULL, SnowflakeParserISNUMERIC, SnowflakeParserISOLATION, SnowflakeParserJAVASCRIPT, SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, SnowflakeParserJDBC_USE_SESSION_TIMEZONE, SnowflakeParserJSON, SnowflakeParserJSON_Q, SnowflakeParserJSON_INDENT, SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, SnowflakeParserKB, SnowflakeParserKEEP, SnowflakeParserKEY, SnowflakeParserKEYS, SnowflakeParserKEYSET, SnowflakeParserKMS_KEY_ID, SnowflakeParserLAG, SnowflakeParserLANGUAGE, SnowflakeParserLARGE, SnowflakeParserLAST, SnowflakeParserLAST_NAME, SnowflakeParserLAST_QUERY_ID, SnowflakeParserLAST_VALUE, SnowflakeParserLEAD, SnowflakeParserLEN, SnowflakeParserLENGTH, SnowflakeParserLEVEL, SnowflakeParserLIMIT, SnowflakeParserLINENO, SnowflakeParserLIST, SnowflakeParserLISTENER_IP, SnowflakeParserLISTENER_PORT, SnowflakeParserLISTING, SnowflakeParserLOAD, SnowflakeParserLOCAL, SnowflakeParserLOCAL_SERVICE_NAME, SnowflakeParserLOCATION, SnowflakeParserLOCKS, SnowflakeParserLOCK_TIMEOUT, SnowflakeParserLOG, SnowflakeParserLOGIN, SnowflakeParserLOGIN_NAME, SnowflakeParserLOOKER, SnowflakeParserLOW, SnowflakeParserLOWER, SnowflakeParserLTRIM, SnowflakeParserLZO, SnowflakeParserMANAGE, SnowflakeParserMANAGED, SnowflakeParserMASK, SnowflakeParserMASKED, SnowflakeParserMASKING, SnowflakeParserMASTER, SnowflakeParserMASTER_KEY, SnowflakeParserMATCH, SnowflakeParserMATCHED, SnowflakeParserMATCHES, SnowflakeParserMATCH_BY_COLUMN_NAME, SnowflakeParserMATCH_RECOGNIZE, SnowflakeParserMATERIALIZED, SnowflakeParserMAX_BATCH_ROWS, SnowflakeParserMAX_CLUSTER_COUNT, SnowflakeParserMAX_CONCURRENCY_LEVEL, SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, SnowflakeParserMAX_SIZE, SnowflakeParserMEASURES, SnowflakeParserMEDIUM, SnowflakeParserMEMOIZABLE, SnowflakeParserMERGE, SnowflakeParserMIDDLE_NAME, SnowflakeParserMIN, SnowflakeParserMINS_TO_BYPASS_MFA, SnowflakeParserMINS_TO_UNLOCK, SnowflakeParserMINUS_, SnowflakeParserMINUTES, SnowflakeParserMIN_CLUSTER_COUNT, SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, SnowflakeParserMODE, SnowflakeParserMODIFIED_AFTER, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserMONITORS, SnowflakeParserMONTHLY, SnowflakeParserMOVE, SnowflakeParserMULTI_STATEMENT_COUNT, SnowflakeParserMULTI_USER, SnowflakeParserMUST_CHANGE, SnowflakeParserMUST_CHANGE_PASSWORD, SnowflakeParserNAME, SnowflakeParserNCHAR, SnowflakeParserNESTED_TRIGGERS, SnowflakeParserNETWORK, SnowflakeParserNETWORK_POLICY, SnowflakeParserNEVER, SnowflakeParserNEWID, SnowflakeParserNEWNAME, SnowflakeParserNEWSEQUENTIALID, SnowflakeParserNEW_ACCOUNT, SnowflakeParserNEW_BROKER, SnowflakeParserNEW_PASSWORD, SnowflakeParserNEXT, SnowflakeParserNEXTVAL, SnowflakeParserNO, SnowflakeParserNONE, SnowflakeParserNONE_Q, SnowflakeParserNORELY, SnowflakeParserNOTIFICATION, SnowflakeParserNOTIFICATIONS, SnowflakeParserNOTIFICATION_INTEGRATION, SnowflakeParserNOTIFICATION_PROVIDER, SnowflakeParserNOTIFY, SnowflakeParserNOTIFY_USERS, SnowflakeParserNOVALIDATE, SnowflakeParserNTILE, SnowflakeParserNULLIF, SnowflakeParserNULLS, SnowflakeParserNULL_, SnowflakeParserNULL_IF, SnowflakeParserNUMANODE, SnowflakeParserNUMBER, SnowflakeParserNUMERIC_ROUNDABORT, SnowflakeParserNVL, SnowflakeParserOAUTH, SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, SnowflakeParserOAUTH_CLIENT, SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, SnowflakeParserOAUTH_ENFORCE_PKCE, SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, SnowflakeParserOAUTH_REDIRECT_URI, SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, SnowflakeParserOAUTH_USE_SECONDARY_ROLES, SnowflakeParserOBJECT, SnowflakeParserOBJECT_Q, SnowflakeParserOBJECTS, SnowflakeParserOBJECT_TYPES, SnowflakeParserOFF, SnowflakeParserOFFSET, SnowflakeParserOFFSETS, SnowflakeParserOKTA, SnowflakeParserOKTA_PROVISIONER_Q, SnowflakeParserOKTA_Q, SnowflakeParserOLD, SnowflakeParserOLD_ACCOUNT, SnowflakeParserOLD_PASSWORD, SnowflakeParserOMIT, SnowflakeParserONE, SnowflakeParserONLINE, SnowflakeParserONLY, SnowflakeParserON_ERROR, SnowflakeParserON_FAILURE, SnowflakeParserOPEN, SnowflakeParserOPERATE, SnowflakeParserOPERATIONS, SnowflakeParserOPTIMIZATION, SnowflakeParserOPTION, SnowflakeParserORC, SnowflakeParserORC_Q, SnowflakeParserORGADMIN, SnowflakeParserOUTBOUND, SnowflakeParserOUTER, SnowflakeParserOVER, SnowflakeParserOVERRIDE, SnowflakeParserOVERWRITE, SnowflakeParserOWNER, SnowflakeParserOWNERSHIP, SnowflakeParserPAGE, SnowflakeParserPARALLEL, SnowflakeParserPARAMETERS, SnowflakeParserPARAM_NODE, SnowflakeParserPARQUET, SnowflakeParserPARQUET_Q, SnowflakeParserPARTIAL, SnowflakeParserPARTITION, SnowflakeParserPARTITIONS, SnowflakeParserPARTITION_TYPE, SnowflakeParserPASSWORD, SnowflakeParserPAST, SnowflakeParserPATH_, SnowflakeParserPATTERN, SnowflakeParserPER, SnowflakeParserPERCENT, SnowflakeParserPERCENTILE_CONT, SnowflakeParserPERCENTILE_DISC, SnowflakeParserPERCENT_RANK, SnowflakeParserPERIODIC_DATA_REKEYING, SnowflakeParserPERMISSION_SET, SnowflakeParserPERSISTED, SnowflakeParserPERSIST_SAMPLE_PERCENT, SnowflakeParserPING_FEDERATE, SnowflakeParserPIPE, SnowflakeParserPIPES, SnowflakeParserPIPE_EXECUTION_PAUSED, SnowflakeParserPIVOT, SnowflakeParserPLAN, SnowflakeParserPLATFORM, SnowflakeParserPOLICIES, SnowflakeParserPOLICY, SnowflakeParserPOOL, SnowflakeParserPORT, SnowflakeParserPRECEDING, SnowflakeParserPRECISION, SnowflakeParserPREDICATE, SnowflakeParserPREFIX, SnowflakeParserPRESERVE_SPACE, SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, SnowflakeParserPRIMARY, SnowflakeParserPRIMARY_ROLE, SnowflakeParserPRIOR, SnowflakeParserPRIORITY, SnowflakeParserPRIORITY_LEVEL, SnowflakeParserPRIVATE, SnowflakeParserPRIVATE_KEY, SnowflakeParserPRIVILEGES, SnowflakeParserPROC, SnowflakeParserPROCEDURE, SnowflakeParserPROCEDURES, SnowflakeParserPROCEDURE_NAME, SnowflakeParserPROCESS, SnowflakeParserPROFILE, SnowflakeParserPROPERTY, SnowflakeParserPROVIDER, SnowflakeParserPROVIDER_KEY_NAME, SnowflakeParserPUBLIC, SnowflakeParserPURGE, SnowflakeParserPUT, SnowflakeParserPYTHON, SnowflakeParserQUERIES, SnowflakeParserQUERY, SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, SnowflakeParserQUERY_TAG, SnowflakeParserQUEUE, SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, SnowflakeParserRANGE, SnowflakeParserRANK, SnowflakeParserRAW_DEFLATE, SnowflakeParserREAD, SnowflakeParserREADER, SnowflakeParserREADONLY, SnowflakeParserREADPAST, SnowflakeParserREADTEXT, SnowflakeParserREADWRITE, SnowflakeParserREAD_COMMITTED_SNAPSHOT, SnowflakeParserREAD_ONLY, SnowflakeParserREAD_ONLY_ROUTING_LIST, SnowflakeParserREAD_WRITE, SnowflakeParserREBUILD, SnowflakeParserRECEIVE, SnowflakeParserRECLUSTER, SnowflakeParserRECOMPILE, SnowflakeParserRECONFIGURE, SnowflakeParserRECORD_DELIMITER, SnowflakeParserRECOVERY, SnowflakeParserRECURSIVE, SnowflakeParserRECURSIVE_TRIGGERS, SnowflakeParserREFERENCES, SnowflakeParserREFERENCE_USAGE, SnowflakeParserREFRESH, SnowflakeParserREFRESH_ON_CREATE, SnowflakeParserREGION, SnowflakeParserREGIONS, SnowflakeParserREGION_GROUP, SnowflakeParserRELATIVE, SnowflakeParserRELY, SnowflakeParserREMOTE, SnowflakeParserREMOTE_PROC_TRANSACTIONS, SnowflakeParserREMOTE_SERVICE_NAME, SnowflakeParserREMOVE, SnowflakeParserRENAME, SnowflakeParserREPEATABLE, SnowflakeParserREPLACE, SnowflakeParserREPLACE_INVALID_CHARACTERS, SnowflakeParserREPLICA, SnowflakeParserREPLICATION, SnowflakeParserREPLICATION_SCHEDULE, SnowflakeParserREQUEST_TRANSLATOR, SnowflakeParserREQUIRED, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, SnowflakeParserRESET, SnowflakeParserRESOURCE, SnowflakeParserRESOURCES, SnowflakeParserRESOURCE_MONITOR, SnowflakeParserRESPONSE_TRANSLATOR, SnowflakeParserRESTART, SnowflakeParserRESTORE, SnowflakeParserRESTRICT, SnowflakeParserRESTRICTIONS, SnowflakeParserRESULT, SnowflakeParserRESUME, SnowflakeParserRETAINDAYS, SnowflakeParserRETURN, SnowflakeParserRETURNS, SnowflakeParserRETURN_ALL_ERRORS, SnowflakeParserRETURN_ERRORS, SnowflakeParserRETURN_FAILED_ONLY, SnowflakeParserRETURN_N_ROWS, SnowflakeParserRETURN_ROWS, SnowflakeParserREVERSE, SnowflakeParserREVERT, SnowflakeParserREWIND, SnowflakeParserROLE, SnowflakeParserROLES, SnowflakeParserROLLBACK, SnowflakeParserROLLUP, SnowflakeParserROOT, SnowflakeParserROWCOUNT, SnowflakeParserROWGUID, SnowflakeParserROWLOCK, SnowflakeParserROWS_PER_RESULTSET, SnowflakeParserROW_NUMBER, SnowflakeParserRSA_PUBLIC_KEY, SnowflakeParserRTRIM, SnowflakeParserRUN_AS_ROLE, SnowflakeParserSAFE, SnowflakeParserSAFETY, SnowflakeParserSAML_IDENTITY_PROVIDER, SnowflakeParserSAVE_OLD_URL, SnowflakeParserSCALING_POLICY, SnowflakeParserSCHEDULE, SnowflakeParserSCHEDULER, SnowflakeParserSCHEMAS, SnowflakeParserSCHEME, SnowflakeParserSCIM, SnowflakeParserSCIM_CLIENT, SnowflakeParserSCRIPT, SnowflakeParserSEARCH, SnowflakeParserSECONDARY, SnowflakeParserSECONDARY_ONLY, SnowflakeParserSECONDARY_ROLE, SnowflakeParserSECONDS, SnowflakeParserSECRET, SnowflakeParserSECURE, SnowflakeParserSECURITY, SnowflakeParserSECURITYADMIN, SnowflakeParserSEED, SnowflakeParserSELF, SnowflakeParserSEQUENCE, SnowflakeParserSEQUENCES, SnowflakeParserSERVER, SnowflakeParserSERVICE, SnowflakeParserSESSION, SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, SnowflakeParserSESSION_POLICY, SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, SnowflakeParserSETS, SnowflakeParserSETUSER, SnowflakeParserSHARE, SnowflakeParserSHARED, SnowflakeParserSHARES, SnowflakeParserSHARE_RESTRICTIONS, SnowflakeParserSHOW, SnowflakeParserSHOWPLAN, SnowflakeParserSHOWPLAN_ALL, SnowflakeParserSHOWPLAN_TEXT, SnowflakeParserSHOWPLAN_XML, SnowflakeParserSHOW_INITIAL_ROWS, SnowflakeParserSIGNATURE, SnowflakeParserSIMPLE, SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, SnowflakeParserSINGLE_USER, SnowflakeParserSIZE, SnowflakeParserSIZE_LIMIT, SnowflakeParserSKIP_, SnowflakeParserSKIP_BLANK_LINES, SnowflakeParserSKIP_BYTE_ORDER_MARK, SnowflakeParserSKIP_FILE, SnowflakeParserSKIP_FILE_N, SnowflakeParserSKIP_HEADER, SnowflakeParserSMALL, SnowflakeParserSNAPPY, SnowflakeParserSNAPPY_COMPRESSION, SnowflakeParserSOUNDEX, SnowflakeParserSOURCE, SnowflakeParserSOURCE_COMPRESSION, SnowflakeParserSPACE_KEYWORD, SnowflakeParserSPARSE, SnowflakeParserSPECIFICATION, SnowflakeParserSPLIT, SnowflakeParserSPLIT_PART, SnowflakeParserSQL, SnowflakeParserSSO_LOGIN_PAGE, SnowflakeParserSTAGE, SnowflakeParserSTAGES, SnowflakeParserSTAGE_COPY_OPTIONS, SnowflakeParserSTAGE_FILE_FORMAT, SnowflakeParserSTANDARD, SnowflakeParserSTANDBY, SnowflakeParserSTARTED, SnowflakeParserSTARTS, SnowflakeParserSTART_DATE, SnowflakeParserSTART_TIMESTAMP, SnowflakeParserSTATE, SnowflakeParserSTATEMENT, SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, SnowflakeParserSTATIC, SnowflakeParserSTATISTICS, SnowflakeParserSTATS, SnowflakeParserSTATS_DATE, SnowflakeParserSTATS_STREAM, SnowflakeParserSTATUS, SnowflakeParserSTATUSONLY, SnowflakeParserSTDEV, SnowflakeParserSTDEVP, SnowflakeParserSTOP, SnowflakeParserSTOPLIST, SnowflakeParserSTOPPED, SnowflakeParserSTORAGE, SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, SnowflakeParserSTORAGE_AWS_OBJECT_ACL, SnowflakeParserSTORAGE_AWS_ROLE_ARN, SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, SnowflakeParserSTORAGE_INTEGRATION, SnowflakeParserSTORAGE_PROVIDER, SnowflakeParserSTR, SnowflakeParserSTREAM, SnowflakeParserSTREAMS, SnowflakeParserSTRICT, SnowflakeParserSTRICT_JSON_OUTPUT, SnowflakeParserSTRING_AGG, SnowflakeParserSTRING_ESCAPE, SnowflakeParserSTRIP_NULL_VALUES, SnowflakeParserSTRIP_OUTER_ARRAY, SnowflakeParserSTRIP_OUTER_ELEMENT, SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING, SnowflakeParserSUM, SnowflakeParserSUPPORTED, SnowflakeParserSUSPEND, SnowflakeParserSUSPENDED, SnowflakeParserSUSPEND_IMMEDIATE, SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, SnowflakeParserSWAP, SnowflakeParserSWITCH, SnowflakeParserSYNC_PASSWORD, SnowflakeParserSYSADMIN, SnowflakeParserSYSTEM, SnowflakeParserSYSTEM_USER, SnowflakeParserTABLEAU_DESKTOP, SnowflakeParserTABLEAU_SERVER, SnowflakeParserTABLES, SnowflakeParserTABLE_FORMAT, SnowflakeParserTABULAR, SnowflakeParserTAG, SnowflakeParserTAGS, SnowflakeParserTARGET, SnowflakeParserTARGET_LAG, SnowflakeParserTASK, SnowflakeParserTASKS, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserTERSE, SnowflakeParserTEXTSIZE, SnowflakeParserTIES, SnowflakeParserTIME, SnowflakeParserTIMEADD, SnowflakeParserTIMEDIFF, SnowflakeParserTIMEOUT, SnowflakeParserTIMER, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_FORMAT, SnowflakeParserTIMESTAMP_INPUT_FORMAT, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_TYPE_MAPPING, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMPADD, SnowflakeParserTIMESTAMPDIFF, SnowflakeParserTIMEZONE, SnowflakeParserTIME_FORMAT, SnowflakeParserTIME_INPUT_FORMAT, SnowflakeParserTIME_OUTPUT_FORMAT, SnowflakeParserTO_BOOLEAN, SnowflakeParserTO_DATE, SnowflakeParserTOP, SnowflakeParserTORN_PAGE_DETECTION, SnowflakeParserTRACKING, SnowflakeParserTRACK_CAUSALITY, SnowflakeParserTRAN, SnowflakeParserTRANSACTION, SnowflakeParserTRANSACTIONS, SnowflakeParserTRANSACTION_ABORT_ON_ERROR, SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, SnowflakeParserTRANSACTION_ID, SnowflakeParserTRANSFORM_NOISE_WORDS, SnowflakeParserTRANSIENT, SnowflakeParserTRANSLATE, SnowflakeParserTRIGGERS, SnowflakeParserTRIM, SnowflakeParserTRIM_SPACE, SnowflakeParserTRIPLE_DES, SnowflakeParserTRUNCATE, SnowflakeParserTRUNCATECOLUMNS, SnowflakeParserTRUSTWORTHY, SnowflakeParserTRY, SnowflakeParserTSEQUAL, SnowflakeParserTSQL, SnowflakeParserTWO_DIGIT_CENTURY_START, SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, SnowflakeParserTYPE, SnowflakeParserTYPEPROPERTY, SnowflakeParserTYPE_ID, SnowflakeParserTYPE_NAME, SnowflakeParserTYPE_WARNING, SnowflakeParserUN, SnowflakeParserUNBOUNDED, SnowflakeParserUNCHECKED, SnowflakeParserUNCOMMITTED, SnowflakeParserUNDROP, SnowflakeParserUNICODE, SnowflakeParserUNKNOWN, SnowflakeParserUNLIMITED, SnowflakeParserUNLOCK, SnowflakeParserUNMASK, SnowflakeParserUNMATCHED, SnowflakeParserUNPIVOT, SnowflakeParserUNSAFE, SnowflakeParserUNSET, SnowflakeParserUNSUPPORTED_DDL_ACTION, SnowflakeParserUOW, SnowflakeParserUPDLOCK, SnowflakeParserUPPER, SnowflakeParserURL, SnowflakeParserUSAGE, SnowflakeParserUSE, SnowflakeParserUSED, SnowflakeParserUSER, SnowflakeParserUSERADMIN, SnowflakeParserUSERS, SnowflakeParserUSER_SPECIFIED, SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, SnowflakeParserUSER_TASK_TIMEOUT_MS, SnowflakeParserUSE_ANY_ROLE, SnowflakeParserUSE_CACHED_RESULT, SnowflakeParserVALIDATE, SnowflakeParserVALIDATION, SnowflakeParserVALIDATION_MODE, SnowflakeParserVALID_XML, SnowflakeParserVALUE, SnowflakeParserVAR, SnowflakeParserVARIABLES, SnowflakeParserVARP, SnowflakeParserVARYING, SnowflakeParserVERSION, SnowflakeParserVIEWS, SnowflakeParserVIEW_METADATA, SnowflakeParserVISIBILITY, SnowflakeParserVOLATILE, SnowflakeParserWAIT, SnowflakeParserWAREHOUSE, SnowflakeParserWAREHOUSES, SnowflakeParserWAREHOUSE_SIZE, SnowflakeParserWEEKLY, SnowflakeParserWEEK_OF_YEAR_POLICY, SnowflakeParserWEEK_START, SnowflakeParserWELL_FORMED_XML, SnowflakeParserWITHIN, SnowflakeParserWITHOUT, SnowflakeParserWITHOUT_ARRAY_WRAPPER, SnowflakeParserWORK, SnowflakeParserWORKLOAD, SnowflakeParserWRITE, SnowflakeParserXLARGE, SnowflakeParserXLOCK, SnowflakeParserXML, SnowflakeParserXML_Q, SnowflakeParserXSMALL, SnowflakeParserXXLARGE, SnowflakeParserXXXLARGE, SnowflakeParserYEARLY, SnowflakeParserZSTD, SnowflakeParserARRAY, SnowflakeParserARRAY_Q, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserCHAR_VARYING, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNCHAR_VARYING, SnowflakeParserNUMERIC, SnowflakeParserNVARCHAR, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT, SnowflakeParserLISTAGG, SnowflakeParserDUMMY, SnowflakeParserDOUBLE_QUOTE_ID, SnowflakeParserDOUBLE_QUOTE_BLANK, SnowflakeParserID, SnowflakeParserID2: + { + p.SetState(5258) + p.Alter_column_decl_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5261) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5262) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5263) + p.Object_name() + } + { + p.SetState(5264) + p.Alter_modify() + } + { + p.SetState(5265) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5266) + p.Column_name() + } + { + p.SetState(5267) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5268) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5269) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5270) + p.Id_() + } + p.SetState(5278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(5271) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5272) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5273) + p.Column_name() + } + { + p.SetState(5274) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5275) + p.Column_list() + } + { + p.SetState(5276) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFORCE { + { + p.SetState(5280) + p.Match(SnowflakeParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5283) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5284) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5285) + p.Object_name() + } + { + p.SetState(5286) + p.Alter_modify() + } + { + p.SetState(5287) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5288) + p.Column_name() + } + { + p.SetState(5289) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5290) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5291) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5293) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5294) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5295) + p.Object_name() + } + { + p.SetState(5296) + p.Alter_modify() + } + { + p.SetState(5297) + p.Column_set_tags() + } + p.SetState(5302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5298) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5299) + p.Column_set_tags() + } + + p.SetState(5304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5305) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5306) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5307) + p.Object_name() + } + { + p.SetState(5308) + p.Alter_modify() + } + { + p.SetState(5309) + p.Column_unset_tags() + } + p.SetState(5314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5310) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5311) + p.Column_unset_tags() + } + + p.SetState(5316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + 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_decl_listContext is an interface to support dynamic dispatch. +type IAlter_column_decl_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlter_column_decl() []IAlter_column_declContext + Alter_column_decl(i int) IAlter_column_declContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_column_decl_listContext differentiates from other interfaces. + IsAlter_column_decl_listContext() +} + +type Alter_column_decl_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_column_decl_listContext() *Alter_column_decl_listContext { + var p = new(Alter_column_decl_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_column_decl_list + return p +} + +func InitEmptyAlter_column_decl_listContext(p *Alter_column_decl_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_column_decl_list +} + +func (*Alter_column_decl_listContext) IsAlter_column_decl_listContext() {} + +func NewAlter_column_decl_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_column_decl_listContext { + var p = new(Alter_column_decl_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_column_decl_list + + return p +} + +func (s *Alter_column_decl_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_column_decl_listContext) AllAlter_column_decl() []IAlter_column_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_column_declContext); ok { + len++ + } + } + + tst := make([]IAlter_column_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_column_declContext); ok { + tst[i] = t.(IAlter_column_declContext) + i++ + } + } + + return tst +} + +func (s *Alter_column_decl_listContext) Alter_column_decl(i int) IAlter_column_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_column_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_column_declContext) +} + +func (s *Alter_column_decl_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_column_decl_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_column_decl_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_column_decl_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_column_decl_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_column_decl_list(s) + } +} + +func (s *Alter_column_decl_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_column_decl_list(s) + } +} + +func (s *Alter_column_decl_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_column_decl_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_column_decl_list() (localctx IAlter_column_decl_listContext) { + localctx = NewAlter_column_decl_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, SnowflakeParserRULE_alter_column_decl_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5319) + p.Alter_column_decl() + } + p.SetState(5324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5320) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5321) + p.Alter_column_decl() + } + + p.SetState(5326) + 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_column_declContext is an interface to support dynamic dispatch. +type IAlter_column_declContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Alter_column_opts() IAlter_column_optsContext + COLUMN() antlr.TerminalNode + + // IsAlter_column_declContext differentiates from other interfaces. + IsAlter_column_declContext() +} + +type Alter_column_declContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_column_declContext() *Alter_column_declContext { + var p = new(Alter_column_declContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_column_decl + return p +} + +func InitEmptyAlter_column_declContext(p *Alter_column_declContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_column_decl +} + +func (*Alter_column_declContext) IsAlter_column_declContext() {} + +func NewAlter_column_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_column_declContext { + var p = new(Alter_column_declContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_column_decl + + return p +} + +func (s *Alter_column_declContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_column_declContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Alter_column_declContext) Alter_column_opts() IAlter_column_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_column_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_column_optsContext) +} + +func (s *Alter_column_declContext) COLUMN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMN, 0) +} + +func (s *Alter_column_declContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_column_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_column_declContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_column_decl(s) + } +} + +func (s *Alter_column_declContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_column_decl(s) + } +} + +func (s *Alter_column_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_column_decl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_column_decl() (localctx IAlter_column_declContext) { + localctx = NewAlter_column_declContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, SnowflakeParserRULE_alter_column_decl) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5327) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5330) + p.Column_name() + } + { + p.SetState(5331) + p.Alter_column_opts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_optsContext is an interface to support dynamic dispatch. +type IAlter_column_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + SET() antlr.TerminalNode + Object_name() IObject_nameContext + DOT() antlr.TerminalNode + NEXTVAL() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + Data_type() IData_typeContext + TYPE() antlr.TerminalNode + DATA() antlr.TerminalNode + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlter_column_optsContext differentiates from other interfaces. + IsAlter_column_optsContext() +} + +type Alter_column_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_column_optsContext() *Alter_column_optsContext { + var p = new(Alter_column_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_column_opts + return p +} + +func InitEmptyAlter_column_optsContext(p *Alter_column_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_column_opts +} + +func (*Alter_column_optsContext) IsAlter_column_optsContext() {} + +func NewAlter_column_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_column_optsContext { + var p = new(Alter_column_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_column_opts + + return p +} + +func (s *Alter_column_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_column_optsContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Alter_column_optsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT, 0) +} + +func (s *Alter_column_optsContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_column_optsContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Alter_column_optsContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *Alter_column_optsContext) NEXTVAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEXTVAL, 0) +} + +func (s *Alter_column_optsContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *Alter_column_optsContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Alter_column_optsContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Alter_column_optsContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Alter_column_optsContext) DATA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA, 0) +} + +func (s *Alter_column_optsContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_column_optsContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_column_optsContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_column_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_column_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_column_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_column_opts(s) + } +} + +func (s *Alter_column_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_column_opts(s) + } +} + +func (s *Alter_column_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_column_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_column_opts() (localctx IAlter_column_optsContext) { + localctx = NewAlter_column_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, SnowflakeParserRULE_alter_column_opts) + var _la int + + p.SetState(5362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 571, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5333) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5334) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5335) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5336) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5337) + p.Object_name() + } + { + p.SetState(5338) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5339) + p.Match(SnowflakeParserNEXTVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(5349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserNOT, SnowflakeParserSET: + p.SetState(5342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET { + { + p.SetState(5341) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5344) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5345) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDROP: + { + p.SetState(5346) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5347) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5348) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + p.SetState(5356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET || _la == SnowflakeParserTYPE { + p.SetState(5353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSET { + { + p.SetState(5351) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5352) + p.Match(SnowflakeParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5355) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5358) + p.Data_type() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5359) + p.Comment_clause() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5360) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5361) + p.Match(SnowflakeParserCOMMENT) + 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 +} + +// IColumn_set_tagsContext is an interface to support dynamic dispatch. +type IColumn_set_tagsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Set_tags() ISet_tagsContext + COLUMN() antlr.TerminalNode + + // IsColumn_set_tagsContext differentiates from other interfaces. + IsColumn_set_tagsContext() +} + +type Column_set_tagsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_set_tagsContext() *Column_set_tagsContext { + var p = new(Column_set_tagsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_set_tags + return p +} + +func InitEmptyColumn_set_tagsContext(p *Column_set_tagsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_set_tags +} + +func (*Column_set_tagsContext) IsColumn_set_tagsContext() {} + +func NewColumn_set_tagsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_set_tagsContext { + var p = new(Column_set_tagsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_set_tags + + return p +} + +func (s *Column_set_tagsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_set_tagsContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_set_tagsContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Column_set_tagsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMN, 0) +} + +func (s *Column_set_tagsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_set_tagsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_set_tagsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_set_tags(s) + } +} + +func (s *Column_set_tagsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_set_tags(s) + } +} + +func (s *Column_set_tagsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_set_tags(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_set_tags() (localctx IColumn_set_tagsContext) { + localctx = NewColumn_set_tagsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, SnowflakeParserRULE_column_set_tags) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5365) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5364) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5367) + p.Column_name() + } + { + p.SetState(5368) + p.Set_tags() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_unset_tagsContext is an interface to support dynamic dispatch. +type IColumn_unset_tagsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMN() antlr.TerminalNode + Column_name() IColumn_nameContext + Unset_tags() IUnset_tagsContext + + // IsColumn_unset_tagsContext differentiates from other interfaces. + IsColumn_unset_tagsContext() +} + +type Column_unset_tagsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_unset_tagsContext() *Column_unset_tagsContext { + var p = new(Column_unset_tagsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_unset_tags + return p +} + +func InitEmptyColumn_unset_tagsContext(p *Column_unset_tagsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_unset_tags +} + +func (*Column_unset_tagsContext) IsColumn_unset_tagsContext() {} + +func NewColumn_unset_tagsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_unset_tagsContext { + var p = new(Column_unset_tagsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_unset_tags + + return p +} + +func (s *Column_unset_tagsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_unset_tagsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMN, 0) +} + +func (s *Column_unset_tagsContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_unset_tagsContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Column_unset_tagsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_unset_tagsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_unset_tagsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_unset_tags(s) + } +} + +func (s *Column_unset_tagsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_unset_tags(s) + } +} + +func (s *Column_unset_tagsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_unset_tags(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_unset_tags() (localctx IColumn_unset_tagsContext) { + localctx = NewColumn_unset_tagsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, SnowflakeParserRULE_column_unset_tags) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5370) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5371) + p.Column_name() + } + { + p.SetState(5372) + p.Unset_tags() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_tagContext is an interface to support dynamic dispatch. +type IAlter_tagContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TAG() antlr.TerminalNode + Alter_tag_opts() IAlter_tag_optsContext + + // IsAlter_tagContext differentiates from other interfaces. + IsAlter_tagContext() +} + +type Alter_tagContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tagContext() *Alter_tagContext { + var p = new(Alter_tagContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_tag + return p +} + +func InitEmptyAlter_tagContext(p *Alter_tagContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_tag +} + +func (*Alter_tagContext) IsAlter_tagContext() {} + +func NewAlter_tagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tagContext { + var p = new(Alter_tagContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_tag + + return p +} + +func (s *Alter_tagContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tagContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_tagContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Alter_tagContext) Alter_tag_opts() IAlter_tag_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tag_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tag_optsContext) +} + +func (s *Alter_tagContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tagContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_tag(s) + } +} + +func (s *Alter_tagContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_tag(s) + } +} + +func (s *Alter_tagContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_tag(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_tag() (localctx IAlter_tagContext) { + localctx = NewAlter_tagContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, SnowflakeParserRULE_alter_tag) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5374) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5375) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5376) + p.Alter_tag_opts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_taskContext is an interface to support dynamic dispatch. +type IAlter_taskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TASK() antlr.TerminalNode + Id_() IId_Context + Resume_suspend() IResume_suspendContext + If_exists() IIf_existsContext + REMOVE() antlr.TerminalNode + AFTER() antlr.TerminalNode + String_list() IString_listContext + ADD() antlr.TerminalNode + SET() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + SCHEDULE() antlr.TerminalNode + ALLOW_OVERLAPPING_EXECUTION() antlr.TerminalNode + True_false() ITrue_falseContext + USER_TASK_TIMEOUT_MS() antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + SUSPEND_TASK_AFTER_NUM_FAILURES() antlr.TerminalNode + Comment_clause() IComment_clauseContext + Session_parameter_init_list() ISession_parameter_init_listContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + Session_parameter_list() ISession_parameter_listContext + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + MODIFY() antlr.TerminalNode + AS() antlr.TerminalNode + Sql() ISqlContext + WHEN() antlr.TerminalNode + Expr() IExprContext + + // IsAlter_taskContext differentiates from other interfaces. + IsAlter_taskContext() +} + +type Alter_taskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_taskContext() *Alter_taskContext { + var p = new(Alter_taskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_task + return p +} + +func InitEmptyAlter_taskContext(p *Alter_taskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_task +} + +func (*Alter_taskContext) IsAlter_taskContext() {} + +func NewAlter_taskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_taskContext { + var p = new(Alter_taskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_task + + return p +} + +func (s *Alter_taskContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_taskContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_taskContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Alter_taskContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_taskContext) Resume_suspend() IResume_suspendContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResume_suspendContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResume_suspendContext) +} + +func (s *Alter_taskContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_taskContext) REMOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOVE, 0) +} + +func (s *Alter_taskContext) AFTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAFTER, 0) +} + +func (s *Alter_taskContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Alter_taskContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_taskContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_taskContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Alter_taskContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_taskContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_taskContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_taskContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_taskContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEDULE, 0) +} + +func (s *Alter_taskContext) ALLOW_OVERLAPPING_EXECUTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_OVERLAPPING_EXECUTION, 0) +} + +func (s *Alter_taskContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_taskContext) USER_TASK_TIMEOUT_MS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_TASK_TIMEOUT_MS, 0) +} + +func (s *Alter_taskContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Alter_taskContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Alter_taskContext) SUSPEND_TASK_AFTER_NUM_FAILURES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, 0) +} + +func (s *Alter_taskContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_taskContext) Session_parameter_init_list() ISession_parameter_init_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_parameter_init_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISession_parameter_init_listContext) +} + +func (s *Alter_taskContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_taskContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_taskContext) Session_parameter_list() ISession_parameter_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_parameter_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISession_parameter_listContext) +} + +func (s *Alter_taskContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_taskContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_taskContext) MODIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODIFY, 0) +} + +func (s *Alter_taskContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Alter_taskContext) Sql() ISqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlContext) +} + +func (s *Alter_taskContext) WHEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHEN, 0) +} + +func (s *Alter_taskContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Alter_taskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_taskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_taskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_task(s) + } +} + +func (s *Alter_taskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_task(s) + } +} + +func (s *Alter_taskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_task(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_task() (localctx IAlter_taskContext) { + localctx = NewAlter_taskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, SnowflakeParserRULE_alter_task) + var _la int + + p.SetState(5501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 595, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5378) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5379) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5381) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 573, p.GetParserRuleContext()) == 1 { + { + p.SetState(5380) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5383) + p.Id_() + } + { + p.SetState(5384) + p.Resume_suspend() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5386) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5387) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5389) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 574, p.GetParserRuleContext()) == 1 { + { + p.SetState(5388) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5391) + p.Id_() + } + { + p.SetState(5392) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5393) + p.Match(SnowflakeParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5394) + p.String_list() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5396) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5397) + p.Match(SnowflakeParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5398) + p.String_list() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5399) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5400) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5402) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 575, p.GetParserRuleContext()) == 1 { + { + p.SetState(5401) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5404) + p.Id_() + } + { + p.SetState(5405) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWAREHOUSE { + { + p.SetState(5406) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5407) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5408) + p.String_() + } + + } + p.SetState(5414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSCHEDULE { + { + p.SetState(5411) + p.Match(SnowflakeParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5412) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5413) + p.String_() + } + + } + p.SetState(5419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOW_OVERLAPPING_EXECUTION { + { + p.SetState(5416) + p.Match(SnowflakeParserALLOW_OVERLAPPING_EXECUTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5417) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5418) + p.True_false() + } + + } + p.SetState(5424) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 579, p.GetParserRuleContext()) == 1 { + { + p.SetState(5421) + p.Match(SnowflakeParserUSER_TASK_TIMEOUT_MS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5422) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5423) + p.Num() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5429) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 580, p.GetParserRuleContext()) == 1 { + { + p.SetState(5426) + p.Match(SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5427) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5428) + p.Num() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5432) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(5431) + p.Comment_clause() + } + + } + p.SetState(5435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-4)) & ^0x3f) == 0 && ((int64(1)<<(_la-4))&3458764515028500481) != 0) || ((int64((_la-100)) & ^0x3f) == 0 && ((int64(1)<<(_la-100))&562675075514371) != 0) || ((int64((_la-209)) & ^0x3f) == 0 && ((int64(1)<<(_la-209))&4631952216750563521) != 0) || ((int64((_la-276)) & ^0x3f) == 0 && ((int64(1)<<(_la-276))&131075) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&-4611615649683210237) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&6917529165080035377) != 0) || ((int64((_la-480)) & ^0x3f) == 0 && ((int64(1)<<(_la-480))&131329) != 0) || ((int64((_la-596)) & ^0x3f) == 0 && ((int64(1)<<(_la-596))&1407374886699137) != 0) || ((int64((_la-691)) & ^0x3f) == 0 && ((int64(1)<<(_la-691))&1152921642045800451) != 0) || ((int64((_la-789)) & ^0x3f) == 0 && ((int64(1)<<(_la-789))&211110527500801) != 0) || ((int64((_la-860)) & ^0x3f) == 0 && ((int64(1)<<(_la-860))&3799525157500887041) != 0) || ((int64((_la-932)) & ^0x3f) == 0 && ((int64(1)<<(_la-932))&792642330511278083) != 0) || _la == SnowflakeParserWEEK_OF_YEAR_POLICY || _la == SnowflakeParserWEEK_START { + { + p.SetState(5434) + p.Session_parameter_init_list() + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5437) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5438) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5440) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 583, p.GetParserRuleContext()) == 1 { + { + p.SetState(5439) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5442) + p.Id_() + } + { + p.SetState(5443) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWAREHOUSE { + { + p.SetState(5444) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSCHEDULE { + { + p.SetState(5447) + p.Match(SnowflakeParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOW_OVERLAPPING_EXECUTION { + { + p.SetState(5450) + p.Match(SnowflakeParserALLOW_OVERLAPPING_EXECUTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5454) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 587, p.GetParserRuleContext()) == 1 { + { + p.SetState(5453) + p.Match(SnowflakeParserUSER_TASK_TIMEOUT_MS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5457) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) == 1 { + { + p.SetState(5456) + p.Match(SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(5459) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-4)) & ^0x3f) == 0 && ((int64(1)<<(_la-4))&3458764515028500481) != 0) || ((int64((_la-100)) & ^0x3f) == 0 && ((int64(1)<<(_la-100))&562675075514371) != 0) || ((int64((_la-209)) & ^0x3f) == 0 && ((int64(1)<<(_la-209))&4631952216750563521) != 0) || ((int64((_la-276)) & ^0x3f) == 0 && ((int64(1)<<(_la-276))&131075) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&-4611615649683210237) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&6917529165080035377) != 0) || ((int64((_la-480)) & ^0x3f) == 0 && ((int64(1)<<(_la-480))&131329) != 0) || ((int64((_la-596)) & ^0x3f) == 0 && ((int64(1)<<(_la-596))&1407374886699137) != 0) || ((int64((_la-691)) & ^0x3f) == 0 && ((int64(1)<<(_la-691))&1152921642045800451) != 0) || ((int64((_la-789)) & ^0x3f) == 0 && ((int64(1)<<(_la-789))&211110527500801) != 0) || ((int64((_la-860)) & ^0x3f) == 0 && ((int64(1)<<(_la-860))&3799525157500887041) != 0) || ((int64((_la-932)) & ^0x3f) == 0 && ((int64(1)<<(_la-932))&792642330511278083) != 0) || _la == SnowflakeParserWEEK_OF_YEAR_POLICY || _la == SnowflakeParserWEEK_START { + { + p.SetState(5462) + p.Session_parameter_list() + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5465) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5466) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5468) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 591, p.GetParserRuleContext()) == 1 { + { + p.SetState(5467) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5470) + p.Id_() + } + { + p.SetState(5471) + p.Set_tags() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5473) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5474) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5476) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 592, p.GetParserRuleContext()) == 1 { + { + p.SetState(5475) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5478) + p.Id_() + } + { + p.SetState(5479) + p.Unset_tags() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5481) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5482) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5484) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 593, p.GetParserRuleContext()) == 1 { + { + p.SetState(5483) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5486) + p.Id_() + } + { + p.SetState(5487) + p.Match(SnowflakeParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5488) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5489) + p.Sql() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5491) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5492) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5494) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 594, p.GetParserRuleContext()) == 1 { + { + p.SetState(5493) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5496) + p.Id_() + } + { + p.SetState(5497) + p.Match(SnowflakeParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5498) + p.Match(SnowflakeParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5499) + p.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 +} + +// IAlter_userContext is an interface to support dynamic dispatch. +type IAlter_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + USER() antlr.TerminalNode + Id_() IId_Context + Alter_user_opts() IAlter_user_optsContext + If_exists() IIf_existsContext + + // IsAlter_userContext differentiates from other interfaces. + IsAlter_userContext() +} + +type Alter_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_userContext() *Alter_userContext { + var p = new(Alter_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_user + return p +} + +func InitEmptyAlter_userContext(p *Alter_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_user +} + +func (*Alter_userContext) IsAlter_userContext() {} + +func NewAlter_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_userContext { + var p = new(Alter_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_user + + return p +} + +func (s *Alter_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_userContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_userContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Alter_userContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_userContext) Alter_user_opts() IAlter_user_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_user_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_user_optsContext) +} + +func (s *Alter_userContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_user(s) + } +} + +func (s *Alter_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_user(s) + } +} + +func (s *Alter_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_user() (localctx IAlter_userContext) { + localctx = NewAlter_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, SnowflakeParserRULE_alter_user) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5503) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5504) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5506) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 596, p.GetParserRuleContext()) == 1 { + { + p.SetState(5505) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5508) + p.Id_() + } + { + p.SetState(5509) + p.Alter_user_opts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_viewContext is an interface to support dynamic dispatch. +type IAlter_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + VIEW() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + SET() antlr.TerminalNode + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + SECURE() antlr.TerminalNode + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + ADD() antlr.TerminalNode + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AllACCESS() []antlr.TerminalNode + ACCESS(i int) antlr.TerminalNode + AllPOLICY() []antlr.TerminalNode + POLICY(i int) antlr.TerminalNode + ON() antlr.TerminalNode + Column_list_in_parentheses() IColumn_list_in_parenthesesContext + DROP() antlr.TerminalNode + COMMA() antlr.TerminalNode + ALL() antlr.TerminalNode + POLICIES() antlr.TerminalNode + Alter_modify() IAlter_modifyContext + MASKING() antlr.TerminalNode + COLUMN() antlr.TerminalNode + USING() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_name() IColumn_nameContext + Column_list() IColumn_listContext + RR_BRACKET() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsAlter_viewContext differentiates from other interfaces. + IsAlter_viewContext() +} + +type Alter_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_viewContext() *Alter_viewContext { + var p = new(Alter_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_view + return p +} + +func InitEmptyAlter_viewContext(p *Alter_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_view +} + +func (*Alter_viewContext) IsAlter_viewContext() {} + +func NewAlter_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_viewContext { + var p = new(Alter_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_view + + return p +} + +func (s *Alter_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_viewContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Alter_viewContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_viewContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_viewContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_viewContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_viewContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_viewContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_viewContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_viewContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_viewContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_viewContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Alter_viewContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_viewContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_viewContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_viewContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserROW) +} + +func (s *Alter_viewContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, i) +} + +func (s *Alter_viewContext) AllACCESS() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserACCESS) +} + +func (s *Alter_viewContext) ACCESS(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, i) +} + +func (s *Alter_viewContext) AllPOLICY() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserPOLICY) +} + +func (s *Alter_viewContext) POLICY(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, i) +} + +func (s *Alter_viewContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Alter_viewContext) Column_list_in_parentheses() IColumn_list_in_parenthesesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_list_in_parenthesesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_list_in_parenthesesContext) +} + +func (s *Alter_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Alter_viewContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Alter_viewContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Alter_viewContext) POLICIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICIES, 0) +} + +func (s *Alter_viewContext) Alter_modify() IAlter_modifyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_modifyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_modifyContext) +} + +func (s *Alter_viewContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Alter_viewContext) COLUMN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMN, 0) +} + +func (s *Alter_viewContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *Alter_viewContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Alter_viewContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Alter_viewContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Alter_viewContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Alter_viewContext) FORCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORCE, 0) +} + +func (s *Alter_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_view(s) + } +} + +func (s *Alter_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_view(s) + } +} + +func (s *Alter_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_view() (localctx IAlter_viewContext) { + localctx = NewAlter_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, SnowflakeParserRULE_alter_view) + var _la int + + p.SetState(5679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 611, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5511) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5512) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5514) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 597, p.GetParserRuleContext()) == 1 { + { + p.SetState(5513) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5516) + p.Id_() + } + { + p.SetState(5517) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5518) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5519) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5521) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5522) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5524) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 598, p.GetParserRuleContext()) == 1 { + { + p.SetState(5523) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5526) + p.Id_() + } + { + p.SetState(5527) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5528) + p.Comment_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5530) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5531) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5533) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 599, p.GetParserRuleContext()) == 1 { + { + p.SetState(5532) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5535) + p.Id_() + } + { + p.SetState(5536) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5537) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5539) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5540) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5541) + p.Id_() + } + { + p.SetState(5542) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5543) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5545) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5546) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5547) + p.Id_() + } + { + p.SetState(5548) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5549) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5551) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5552) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5554) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 600, p.GetParserRuleContext()) == 1 { + { + p.SetState(5553) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5556) + p.Id_() + } + { + p.SetState(5557) + p.Set_tags() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5559) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5560) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5562) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 601, p.GetParserRuleContext()) == 1 { + { + p.SetState(5561) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5564) + p.Id_() + } + { + p.SetState(5565) + p.Unset_tags() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5567) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5568) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5570) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 602, p.GetParserRuleContext()) == 1 { + { + p.SetState(5569) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5572) + p.Id_() + } + { + p.SetState(5573) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5574) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5575) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5576) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5577) + p.Id_() + } + { + p.SetState(5578) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5579) + p.Column_list_in_parentheses() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5581) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5582) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5584) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 603, p.GetParserRuleContext()) == 1 { + { + p.SetState(5583) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5586) + p.Id_() + } + { + p.SetState(5587) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5588) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5589) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5590) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5591) + p.Id_() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(5593) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5594) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5596) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 604, p.GetParserRuleContext()) == 1 { + { + p.SetState(5595) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5598) + p.Id_() + } + { + p.SetState(5599) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5600) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5601) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5602) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5603) + p.Id_() + } + { + p.SetState(5604) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5605) + p.Column_list_in_parentheses() + } + { + p.SetState(5606) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5607) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5608) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5609) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5610) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5611) + p.Id_() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(5613) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5614) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5616) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 605, p.GetParserRuleContext()) == 1 { + { + p.SetState(5615) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5618) + p.Id_() + } + { + p.SetState(5619) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5620) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5621) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5622) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5623) + p.Match(SnowflakeParserPOLICIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(5625) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5626) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5627) + p.Id_() + } + { + p.SetState(5628) + p.Alter_modify() + } + p.SetState(5630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5629) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5632) + p.Id_() + } + { + p.SetState(5633) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5634) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5635) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5636) + p.Id_() + } + p.SetState(5644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(5637) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5638) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5639) + p.Column_name() + } + { + p.SetState(5640) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5641) + p.Column_list() + } + { + p.SetState(5642) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFORCE { + { + p.SetState(5646) + p.Match(SnowflakeParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(5649) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5650) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5651) + p.Id_() + } + { + p.SetState(5652) + p.Alter_modify() + } + p.SetState(5654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5653) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5656) + p.Id_() + } + { + p.SetState(5657) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5658) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5659) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(5661) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5662) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5663) + p.Id_() + } + { + p.SetState(5664) + p.Alter_modify() + } + p.SetState(5666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOLUMN { + { + p.SetState(5665) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5668) + p.Id_() + } + { + p.SetState(5669) + p.Set_tags() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(5671) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5672) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5673) + p.Id_() + } + { + p.SetState(5674) + p.Alter_modify() + } + { + p.SetState(5675) + p.Match(SnowflakeParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5676) + p.Id_() + } + { + p.SetState(5677) + p.Unset_tags() + } + + 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_modifyContext is an interface to support dynamic dispatch. +type IAlter_modifyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MODIFY() antlr.TerminalNode + + // IsAlter_modifyContext differentiates from other interfaces. + IsAlter_modifyContext() +} + +type Alter_modifyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_modifyContext() *Alter_modifyContext { + var p = new(Alter_modifyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_modify + return p +} + +func InitEmptyAlter_modifyContext(p *Alter_modifyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_modify +} + +func (*Alter_modifyContext) IsAlter_modifyContext() {} + +func NewAlter_modifyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_modifyContext { + var p = new(Alter_modifyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_modify + + return p +} + +func (s *Alter_modifyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_modifyContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_modifyContext) MODIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODIFY, 0) +} + +func (s *Alter_modifyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_modifyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_modifyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_modify(s) + } +} + +func (s *Alter_modifyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_modify(s) + } +} + +func (s *Alter_modifyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_modify(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_modify() (localctx IAlter_modifyContext) { + localctx = NewAlter_modifyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, SnowflakeParserRULE_alter_modify) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5681) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserALTER || _la == SnowflakeParserMODIFY) { + 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 +} + +// IAlter_warehouseContext is an interface to support dynamic dispatch. +type IAlter_warehouseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + Alter_warehouse_opts() IAlter_warehouse_optsContext + If_exists() IIf_existsContext + + // IsAlter_warehouseContext differentiates from other interfaces. + IsAlter_warehouseContext() +} + +type Alter_warehouseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_warehouseContext() *Alter_warehouseContext { + var p = new(Alter_warehouseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_warehouse + return p +} + +func InitEmptyAlter_warehouseContext(p *Alter_warehouseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_warehouse +} + +func (*Alter_warehouseContext) IsAlter_warehouseContext() {} + +func NewAlter_warehouseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_warehouseContext { + var p = new(Alter_warehouseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_warehouse + + return p +} + +func (s *Alter_warehouseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_warehouseContext) ALTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALTER, 0) +} + +func (s *Alter_warehouseContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Alter_warehouseContext) Alter_warehouse_opts() IAlter_warehouse_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_warehouse_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_warehouse_optsContext) +} + +func (s *Alter_warehouseContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_warehouseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_warehouseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_warehouseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_warehouse(s) + } +} + +func (s *Alter_warehouseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_warehouse(s) + } +} + +func (s *Alter_warehouseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_warehouse(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_warehouse() (localctx IAlter_warehouseContext) { + localctx = NewAlter_warehouseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, SnowflakeParserRULE_alter_warehouse) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5683) + p.Match(SnowflakeParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5684) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5686) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 612, p.GetParserRuleContext()) == 1 { + { + p.SetState(5685) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5688) + p.Alter_warehouse_opts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_connection_optsContext is an interface to support dynamic dispatch. +type IAlter_connection_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + ENABLE() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + TO() antlr.TerminalNode + ACCOUNTS() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Ignore_edition_check() IIgnore_edition_checkContext + DISABLE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + SET() antlr.TerminalNode + Comment_clause() IComment_clauseContext + If_exists() IIf_existsContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + + // IsAlter_connection_optsContext differentiates from other interfaces. + IsAlter_connection_optsContext() +} + +type Alter_connection_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_connection_optsContext() *Alter_connection_optsContext { + var p = new(Alter_connection_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_connection_opts + return p +} + +func InitEmptyAlter_connection_optsContext(p *Alter_connection_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_connection_opts +} + +func (*Alter_connection_optsContext) IsAlter_connection_optsContext() {} + +func NewAlter_connection_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_connection_optsContext { + var p = new(Alter_connection_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_connection_opts + + return p +} + +func (s *Alter_connection_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_connection_optsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_connection_optsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_connection_optsContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *Alter_connection_optsContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, 0) +} + +func (s *Alter_connection_optsContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_connection_optsContext) ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTS, 0) +} + +func (s *Alter_connection_optsContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserDOT) +} + +func (s *Alter_connection_optsContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, i) +} + +func (s *Alter_connection_optsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_connection_optsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_connection_optsContext) Ignore_edition_check() IIgnore_edition_checkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIgnore_edition_checkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIgnore_edition_checkContext) +} + +func (s *Alter_connection_optsContext) DISABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE, 0) +} + +func (s *Alter_connection_optsContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Alter_connection_optsContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_connection_optsContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_connection_optsContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_connection_optsContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_connection_optsContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_connection_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_connection_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_connection_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_connection_opts(s) + } +} + +func (s *Alter_connection_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_connection_opts(s) + } +} + +func (s *Alter_connection_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_connection_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_connection_opts() (localctx IAlter_connection_optsContext) { + localctx = NewAlter_connection_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, SnowflakeParserRULE_alter_connection_opts) + var _la int + + p.SetState(5743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 618, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5690) + p.Id_() + } + { + p.SetState(5691) + p.Match(SnowflakeParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5692) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5693) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5694) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5695) + p.Id_() + } + { + p.SetState(5696) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5697) + p.Id_() + } + p.SetState(5705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5698) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5699) + p.Id_() + } + { + p.SetState(5700) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5701) + p.Id_() + } + + p.SetState(5707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIGNORE { + { + p.SetState(5708) + p.Ignore_edition_check() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5711) + p.Id_() + } + { + p.SetState(5712) + p.Match(SnowflakeParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5713) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTO { + { + p.SetState(5714) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5715) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5716) + p.Id_() + } + { + p.SetState(5717) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5718) + p.Id_() + } + + { + p.SetState(5719) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5720) + p.Id_() + } + { + p.SetState(5721) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5722) + p.Id_() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5726) + p.Id_() + } + { + p.SetState(5727) + p.Match(SnowflakeParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + p.SetState(5730) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 616, p.GetParserRuleContext()) == 1 { + { + p.SetState(5729) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5732) + p.Id_() + } + { + p.SetState(5733) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5734) + p.Comment_clause() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + p.SetState(5737) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 617, p.GetParserRuleContext()) == 1 { + { + p.SetState(5736) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5739) + p.Id_() + } + { + p.SetState(5740) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5741) + p.Match(SnowflakeParserCOMMENT) + 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 +} + +// IAlter_user_optsContext is an interface to support dynamic dispatch. +type IAlter_user_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RESET() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + ABORT() antlr.TerminalNode + ALL() antlr.TerminalNode + QUERIES() antlr.TerminalNode + ADD() antlr.TerminalNode + DELEGATED() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + OF() antlr.TerminalNode + ROLE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + REMOVE() antlr.TerminalNode + FROM() antlr.TerminalNode + AUTHORIZATIONS() antlr.TerminalNode + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + + // IsAlter_user_optsContext differentiates from other interfaces. + IsAlter_user_optsContext() +} + +type Alter_user_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_user_optsContext() *Alter_user_optsContext { + var p = new(Alter_user_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_user_opts + return p +} + +func InitEmptyAlter_user_optsContext(p *Alter_user_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_user_opts +} + +func (*Alter_user_optsContext) IsAlter_user_optsContext() {} + +func NewAlter_user_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_user_optsContext { + var p = new(Alter_user_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_user_opts + + return p +} + +func (s *Alter_user_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_user_optsContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_user_optsContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_user_optsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_user_optsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_user_optsContext) RESET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESET, 0) +} + +func (s *Alter_user_optsContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPASSWORD, 0) +} + +func (s *Alter_user_optsContext) ABORT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT, 0) +} + +func (s *Alter_user_optsContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Alter_user_optsContext) QUERIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERIES, 0) +} + +func (s *Alter_user_optsContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_user_optsContext) DELEGATED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELEGATED, 0) +} + +func (s *Alter_user_optsContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTHORIZATION, 0) +} + +func (s *Alter_user_optsContext) OF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOF, 0) +} + +func (s *Alter_user_optsContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Alter_user_optsContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Alter_user_optsContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Alter_user_optsContext) REMOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOVE, 0) +} + +func (s *Alter_user_optsContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Alter_user_optsContext) AUTHORIZATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTHORIZATIONS, 0) +} + +func (s *Alter_user_optsContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_user_optsContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_user_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_user_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_user_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_user_opts(s) + } +} + +func (s *Alter_user_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_user_opts(s) + } +} + +func (s *Alter_user_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_user_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_user_opts() (localctx IAlter_user_optsContext) { + localctx = NewAlter_user_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, SnowflakeParserRULE_alter_user_opts) + p.SetState(5779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserRENAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5745) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5746) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5747) + p.Id_() + } + + case SnowflakeParserRESET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5748) + p.Match(SnowflakeParserRESET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5749) + p.Match(SnowflakeParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserABORT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5750) + p.Match(SnowflakeParserABORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5751) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5752) + p.Match(SnowflakeParserQUERIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserADD: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5753) + p.Match(SnowflakeParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5754) + p.Match(SnowflakeParserDELEGATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5755) + p.Match(SnowflakeParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5756) + p.Match(SnowflakeParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5757) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5758) + p.Id_() + } + { + p.SetState(5759) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5760) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5761) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5762) + p.Id_() + } + + case SnowflakeParserREMOVE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5764) + p.Match(SnowflakeParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5765) + p.Match(SnowflakeParserDELEGATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAUTHORIZATION: + { + p.SetState(5766) + p.Match(SnowflakeParserAUTHORIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5767) + p.Match(SnowflakeParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5768) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5769) + p.Id_() + } + + case SnowflakeParserAUTHORIZATIONS: + { + p.SetState(5770) + p.Match(SnowflakeParserAUTHORIZATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5773) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5774) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5775) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5776) + p.Id_() + } + + case SnowflakeParserSET: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5777) + p.Set_tags() + } + + case SnowflakeParserUNSET: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5778) + p.Unset_tags() + } + + 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_tag_optsContext is an interface to support dynamic dispatch. +type IAlter_tag_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + If_exists() IIf_existsContext + ALLOWED_VALUES() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + UNSET() antlr.TerminalNode + SET() antlr.TerminalNode + AllMASKING() []antlr.TerminalNode + MASKING(i int) antlr.TerminalNode + AllPOLICY() []antlr.TerminalNode + POLICY(i int) antlr.TerminalNode + Comment_clause() IComment_clauseContext + COMMENT() antlr.TerminalNode + + // IsAlter_tag_optsContext differentiates from other interfaces. + IsAlter_tag_optsContext() +} + +type Alter_tag_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tag_optsContext() *Alter_tag_optsContext { + var p = new(Alter_tag_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_tag_opts + return p +} + +func InitEmptyAlter_tag_optsContext(p *Alter_tag_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_tag_opts +} + +func (*Alter_tag_optsContext) IsAlter_tag_optsContext() {} + +func NewAlter_tag_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tag_optsContext { + var p = new(Alter_tag_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_tag_opts + + return p +} + +func (s *Alter_tag_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tag_optsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_tag_optsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_tag_optsContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_tag_optsContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_tag_optsContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_tag_optsContext) ALLOWED_VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_VALUES, 0) +} + +func (s *Alter_tag_optsContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Alter_tag_optsContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Alter_tag_optsContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Alter_tag_optsContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Alter_tag_optsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_tag_optsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_tag_optsContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_tag_optsContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_tag_optsContext) AllMASKING() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserMASKING) +} + +func (s *Alter_tag_optsContext) MASKING(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, i) +} + +func (s *Alter_tag_optsContext) AllPOLICY() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserPOLICY) +} + +func (s *Alter_tag_optsContext) POLICY(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, i) +} + +func (s *Alter_tag_optsContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_tag_optsContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_tag_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tag_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tag_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_tag_opts(s) + } +} + +func (s *Alter_tag_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_tag_opts(s) + } +} + +func (s *Alter_tag_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_tag_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_tag_opts() (localctx IAlter_tag_optsContext) { + localctx = NewAlter_tag_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, SnowflakeParserRULE_alter_tag_opts) + var _la int + + p.SetState(5849) + 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(5782) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 621, p.GetParserRuleContext()) == 1 { + { + p.SetState(5781) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5784) + p.Id_() + } + { + p.SetState(5785) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5786) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5787) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5790) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 622, p.GetParserRuleContext()) == 1 { + { + p.SetState(5789) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5792) + p.Id_() + } + { + p.SetState(5793) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserADD || _la == SnowflakeParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5794) + p.Match(SnowflakeParserALLOWED_VALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5795) + p.String_() + } + p.SetState(5800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5796) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5797) + p.String_() + } + + p.SetState(5802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5803) + p.Id_() + } + { + p.SetState(5804) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5805) + p.Match(SnowflakeParserALLOWED_VALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5807) + p.Id_() + } + { + p.SetState(5808) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5809) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5810) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5811) + p.Id_() + } + p.SetState(5818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5812) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5813) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5814) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5815) + p.Id_() + } + + p.SetState(5820) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5821) + p.Id_() + } + { + p.SetState(5822) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5823) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5824) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5825) + p.Id_() + } + p.SetState(5832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5826) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5827) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5828) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5829) + p.Id_() + } + + p.SetState(5834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 6: + p.EnterOuterAlt(localctx, 6) + p.SetState(5836) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 626, p.GetParserRuleContext()) == 1 { + { + p.SetState(5835) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5838) + p.Id_() + } + { + p.SetState(5839) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5840) + p.Comment_clause() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + p.SetState(5843) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 627, p.GetParserRuleContext()) == 1 { + { + p.SetState(5842) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5845) + p.Id_() + } + { + p.SetState(5846) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5847) + p.Match(SnowflakeParserCOMMENT) + 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 +} + +// IAlter_network_policy_optsContext is an interface to support dynamic dispatch. +type IAlter_network_policy_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + SET() antlr.TerminalNode + If_exists() IIf_existsContext + ALLOWED_IP_LIST() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllString_list() []IString_listContext + String_list(i int) IString_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + BLOCKED_IP_LIST() antlr.TerminalNode + Comment_clause() IComment_clauseContext + UNSET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + + // IsAlter_network_policy_optsContext differentiates from other interfaces. + IsAlter_network_policy_optsContext() +} + +type Alter_network_policy_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_network_policy_optsContext() *Alter_network_policy_optsContext { + var p = new(Alter_network_policy_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_network_policy_opts + return p +} + +func InitEmptyAlter_network_policy_optsContext(p *Alter_network_policy_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_network_policy_opts +} + +func (*Alter_network_policy_optsContext) IsAlter_network_policy_optsContext() {} + +func NewAlter_network_policy_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_network_policy_optsContext { + var p = new(Alter_network_policy_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_network_policy_opts + + return p +} + +func (s *Alter_network_policy_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_network_policy_optsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_network_policy_optsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_network_policy_optsContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_network_policy_optsContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Alter_network_policy_optsContext) ALLOWED_IP_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_IP_LIST, 0) +} + +func (s *Alter_network_policy_optsContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Alter_network_policy_optsContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Alter_network_policy_optsContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Alter_network_policy_optsContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Alter_network_policy_optsContext) AllString_list() []IString_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_listContext); ok { + len++ + } + } + + tst := make([]IString_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_listContext); ok { + tst[i] = t.(IString_listContext) + i++ + } + } + + return tst +} + +func (s *Alter_network_policy_optsContext) String_list(i int) IString_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Alter_network_policy_optsContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Alter_network_policy_optsContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Alter_network_policy_optsContext) BLOCKED_IP_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBLOCKED_IP_LIST, 0) +} + +func (s *Alter_network_policy_optsContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Alter_network_policy_optsContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_network_policy_optsContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Alter_network_policy_optsContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_network_policy_optsContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_network_policy_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_network_policy_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_network_policy_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_network_policy_opts(s) + } +} + +func (s *Alter_network_policy_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_network_policy_opts(s) + } +} + +func (s *Alter_network_policy_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_network_policy_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_network_policy_opts() (localctx IAlter_network_policy_optsContext) { + localctx = NewAlter_network_policy_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, SnowflakeParserRULE_alter_network_policy_opts) + var _la int + + p.SetState(5887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 634, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5852) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 629, p.GetParserRuleContext()) == 1 { + { + p.SetState(5851) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5854) + p.Id_() + } + { + p.SetState(5855) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOWED_IP_LIST { + { + p.SetState(5856) + p.Match(SnowflakeParserALLOWED_IP_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5857) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5858) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5859) + p.String_list() + } + { + p.SetState(5860) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserBLOCKED_IP_LIST { + { + p.SetState(5864) + p.Match(SnowflakeParserBLOCKED_IP_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5865) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5866) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5867) + p.String_list() + } + { + p.SetState(5868) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(5872) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5876) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 633, p.GetParserRuleContext()) == 1 { + { + p.SetState(5875) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5878) + p.Id_() + } + { + p.SetState(5879) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5880) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5882) + p.Id_() + } + { + p.SetState(5883) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5884) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5885) + p.Id_() + } + + 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_warehouse_optsContext is an interface to support dynamic dispatch. +type IAlter_warehouse_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUSPEND() antlr.TerminalNode + RESUME() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + If_suspended() IIf_suspendedContext + ABORT() antlr.TerminalNode + ALL() antlr.TerminalNode + QUERIES() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + UNSET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_warehouse_optsContext differentiates from other interfaces. + IsAlter_warehouse_optsContext() +} + +type Alter_warehouse_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_warehouse_optsContext() *Alter_warehouse_optsContext { + var p = new(Alter_warehouse_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_warehouse_opts + return p +} + +func InitEmptyAlter_warehouse_optsContext(p *Alter_warehouse_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_warehouse_opts +} + +func (*Alter_warehouse_optsContext) IsAlter_warehouse_optsContext() {} + +func NewAlter_warehouse_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_warehouse_optsContext { + var p = new(Alter_warehouse_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_warehouse_opts + + return p +} + +func (s *Alter_warehouse_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_warehouse_optsContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND, 0) +} + +func (s *Alter_warehouse_optsContext) RESUME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESUME, 0) +} + +func (s *Alter_warehouse_optsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_warehouse_optsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_warehouse_optsContext) If_suspended() IIf_suspendedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_suspendedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_suspendedContext) +} + +func (s *Alter_warehouse_optsContext) ABORT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT, 0) +} + +func (s *Alter_warehouse_optsContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Alter_warehouse_optsContext) QUERIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERIES, 0) +} + +func (s *Alter_warehouse_optsContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_warehouse_optsContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_warehouse_optsContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_warehouse_optsContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_warehouse_optsContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_warehouse_optsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Alter_warehouse_optsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Alter_warehouse_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_warehouse_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_warehouse_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_warehouse_opts(s) + } +} + +func (s *Alter_warehouse_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_warehouse_opts(s) + } +} + +func (s *Alter_warehouse_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_warehouse_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_warehouse_opts() (localctx IAlter_warehouse_optsContext) { + localctx = NewAlter_warehouse_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, SnowflakeParserRULE_alter_warehouse_opts) + var _la int + + p.SetState(5926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 640, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5890) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 635, p.GetParserRuleContext()) == 1 { + { + p.SetState(5889) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSUSPEND: + { + p.SetState(5892) + p.Match(SnowflakeParserSUSPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRESUME: + { + p.SetState(5893) + p.Match(SnowflakeParserRESUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIF { + { + p.SetState(5894) + p.If_suspended() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5900) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 638, p.GetParserRuleContext()) == 1 { + { + p.SetState(5899) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5902) + p.Match(SnowflakeParserABORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5903) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5904) + p.Match(SnowflakeParserQUERIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5905) + p.Id_() + } + { + p.SetState(5906) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5907) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5908) + p.Id_() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5910) + p.Id_() + } + { + p.SetState(5911) + p.Set_tags() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5913) + p.Id_() + } + { + p.SetState(5914) + p.Unset_tags() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5916) + p.Id_() + } + { + p.SetState(5917) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5918) + p.Id_() + } + p.SetState(5923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(5919) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5920) + p.Id_() + } + + p.SetState(5925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + 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_account_optsContext is an interface to support dynamic dispatch. +type IAlter_account_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + Account_params() IAccount_paramsContext + Object_params() IObject_paramsContext + Session_params() ISession_paramsContext + UNSET() antlr.TerminalNode + AllParam_name() []IParam_nameContext + Param_name(i int) IParam_nameContext + COMMA() antlr.TerminalNode + RESOURCE_MONITOR() antlr.TerminalNode + EQ() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + Set_tags() ISet_tagsContext + Unset_tags() IUnset_tagsContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + SAVE_OLD_URL() antlr.TerminalNode + True_false() ITrue_falseContext + DROP() antlr.TerminalNode + OLD() antlr.TerminalNode + URL() antlr.TerminalNode + + // IsAlter_account_optsContext differentiates from other interfaces. + IsAlter_account_optsContext() +} + +type Alter_account_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_account_optsContext() *Alter_account_optsContext { + var p = new(Alter_account_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_account_opts + return p +} + +func InitEmptyAlter_account_optsContext(p *Alter_account_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alter_account_opts +} + +func (*Alter_account_optsContext) IsAlter_account_optsContext() {} + +func NewAlter_account_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_account_optsContext { + var p = new(Alter_account_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alter_account_opts + + return p +} + +func (s *Alter_account_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_account_optsContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Alter_account_optsContext) Account_params() IAccount_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccount_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccount_paramsContext) +} + +func (s *Alter_account_optsContext) Object_params() IObject_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_paramsContext) +} + +func (s *Alter_account_optsContext) Session_params() ISession_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISession_paramsContext) +} + +func (s *Alter_account_optsContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Alter_account_optsContext) AllParam_name() []IParam_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParam_nameContext); ok { + len++ + } + } + + tst := make([]IParam_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParam_nameContext); ok { + tst[i] = t.(IParam_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_account_optsContext) Param_name(i int) IParam_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParam_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParam_nameContext) +} + +func (s *Alter_account_optsContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Alter_account_optsContext) RESOURCE_MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE_MONITOR, 0) +} + +func (s *Alter_account_optsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Alter_account_optsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Alter_account_optsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Alter_account_optsContext) Set_tags() ISet_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_tagsContext) +} + +func (s *Alter_account_optsContext) Unset_tags() IUnset_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnset_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnset_tagsContext) +} + +func (s *Alter_account_optsContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Alter_account_optsContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Alter_account_optsContext) SAVE_OLD_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAVE_OLD_URL, 0) +} + +func (s *Alter_account_optsContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Alter_account_optsContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Alter_account_optsContext) OLD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOLD, 0) +} + +func (s *Alter_account_optsContext) URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserURL, 0) +} + +func (s *Alter_account_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_account_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_account_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlter_account_opts(s) + } +} + +func (s *Alter_account_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlter_account_opts(s) + } +} + +func (s *Alter_account_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlter_account_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alter_account_opts() (localctx IAlter_account_optsContext) { + localctx = NewAlter_account_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, SnowflakeParserRULE_alter_account_opts) + var _la int + + p.SetState(5964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 646, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5928) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5930) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 641, p.GetParserRuleContext()) == 1 { + { + p.SetState(5929) + p.Account_params() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5933) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext()) == 1 { + { + p.SetState(5932) + p.Object_params() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserABORT_DETACHED_QUERY || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&206158430209) != 0) || ((int64((_la-215)) & ^0x3f) == 0 && ((int64(1)<<(_la-215))&6917529027641081859) != 0) || _la == SnowflakeParserJSON_INDENT || _la == SnowflakeParserLOCK_TIMEOUT || _la == SnowflakeParserQUERY_TAG || _la == SnowflakeParserROWS_PER_RESULTSET || ((int64((_la-798)) & ^0x3f) == 0 && ((int64(1)<<(_la-798))&4611686293305294849) != 0) || ((int64((_la-905)) & ^0x3f) == 0 && ((int64(1)<<(_la-905))&140737756898773) != 0) || ((int64((_la-975)) & ^0x3f) == 0 && ((int64(1)<<(_la-975))&3298534948865) != 0) { + { + p.SetState(5935) + p.Session_params() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5938) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5939) + p.Param_name() + } + p.SetState(5942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMA { + { + p.SetState(5940) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5941) + p.Param_name() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5944) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5945) + p.Match(SnowflakeParserRESOURCE_MONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5946) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5947) + p.Id_() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5948) + p.Set_tags() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5949) + p.Unset_tags() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5950) + p.Id_() + } + { + p.SetState(5951) + p.Match(SnowflakeParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5952) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5953) + p.Id_() + } + p.SetState(5957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAVE_OLD_URL { + { + p.SetState(5954) + p.Match(SnowflakeParserSAVE_OLD_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5955) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5956) + p.True_false() + } + + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5959) + p.Id_() + } + { + p.SetState(5960) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5961) + p.Match(SnowflakeParserOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5962) + p.Match(SnowflakeParserURL) + 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 +} + +// ISet_tagsContext is an interface to support dynamic dispatch. +type ISet_tagsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + Tag_decl_list() ITag_decl_listContext + + // IsSet_tagsContext differentiates from other interfaces. + IsSet_tagsContext() +} + +type Set_tagsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_tagsContext() *Set_tagsContext { + var p = new(Set_tagsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_set_tags + return p +} + +func InitEmptySet_tagsContext(p *Set_tagsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_set_tags +} + +func (*Set_tagsContext) IsSet_tagsContext() {} + +func NewSet_tagsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_tagsContext { + var p = new(Set_tagsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_set_tags + + return p +} + +func (s *Set_tagsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_tagsContext) SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSET, 0) +} + +func (s *Set_tagsContext) Tag_decl_list() ITag_decl_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITag_decl_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITag_decl_listContext) +} + +func (s *Set_tagsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_tagsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_tagsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSet_tags(s) + } +} + +func (s *Set_tagsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSet_tags(s) + } +} + +func (s *Set_tagsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSet_tags(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Set_tags() (localctx ISet_tagsContext) { + localctx = NewSet_tagsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, SnowflakeParserRULE_set_tags) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5966) + p.Match(SnowflakeParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5967) + p.Tag_decl_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 +} + +// ITag_decl_listContext is an interface to support dynamic dispatch. +type ITag_decl_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TAG() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllTag_value() []ITag_valueContext + Tag_value(i int) ITag_valueContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTag_decl_listContext differentiates from other interfaces. + IsTag_decl_listContext() +} + +type Tag_decl_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTag_decl_listContext() *Tag_decl_listContext { + var p = new(Tag_decl_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_tag_decl_list + return p +} + +func InitEmptyTag_decl_listContext(p *Tag_decl_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_tag_decl_list +} + +func (*Tag_decl_listContext) IsTag_decl_listContext() {} + +func NewTag_decl_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tag_decl_listContext { + var p = new(Tag_decl_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_tag_decl_list + + return p +} + +func (s *Tag_decl_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tag_decl_listContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Tag_decl_listContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Tag_decl_listContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Tag_decl_listContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Tag_decl_listContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Tag_decl_listContext) AllTag_value() []ITag_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITag_valueContext); ok { + len++ + } + } + + tst := make([]ITag_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITag_valueContext); ok { + tst[i] = t.(ITag_valueContext) + i++ + } + } + + return tst +} + +func (s *Tag_decl_listContext) Tag_value(i int) ITag_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITag_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITag_valueContext) +} + +func (s *Tag_decl_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Tag_decl_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Tag_decl_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tag_decl_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tag_decl_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTag_decl_list(s) + } +} + +func (s *Tag_decl_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTag_decl_list(s) + } +} + +func (s *Tag_decl_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTag_decl_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Tag_decl_list() (localctx ITag_decl_listContext) { + localctx = NewTag_decl_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, SnowflakeParserRULE_tag_decl_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5969) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5970) + p.Id_() + } + { + p.SetState(5971) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5972) + p.Tag_value() + } + p.SetState(5980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 647, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5973) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5974) + p.Id_() + } + { + p.SetState(5975) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5976) + p.Tag_value() + } + + } + p.SetState(5982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 647, 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 +} + +// IUnset_tagsContext is an interface to support dynamic dispatch. +type IUnset_tagsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSET() antlr.TerminalNode + TAG() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUnset_tagsContext differentiates from other interfaces. + IsUnset_tagsContext() +} + +type Unset_tagsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnset_tagsContext() *Unset_tagsContext { + var p = new(Unset_tagsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_unset_tags + return p +} + +func InitEmptyUnset_tagsContext(p *Unset_tagsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_unset_tags +} + +func (*Unset_tagsContext) IsUnset_tagsContext() {} + +func NewUnset_tagsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unset_tagsContext { + var p = new(Unset_tagsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_unset_tags + + return p +} + +func (s *Unset_tagsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unset_tagsContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Unset_tagsContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Unset_tagsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Unset_tagsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Unset_tagsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Unset_tagsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Unset_tagsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unset_tagsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unset_tagsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUnset_tags(s) + } +} + +func (s *Unset_tagsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUnset_tags(s) + } +} + +func (s *Unset_tagsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUnset_tags(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Unset_tags() (localctx IUnset_tagsContext) { + localctx = NewUnset_tagsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, SnowflakeParserRULE_unset_tags) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5983) + p.Match(SnowflakeParserUNSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5984) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5985) + p.Id_() + } + p.SetState(5990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 648, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5986) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5987) + p.Id_() + } + + } + p.SetState(5992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 648, 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 +} + +// ICreate_commandContext is an interface to support dynamic dispatch. +type ICreate_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Create_account() ICreate_accountContext + Create_alert() ICreate_alertContext + Create_api_integration() ICreate_api_integrationContext + Create_object_clone() ICreate_object_cloneContext + Create_connection() ICreate_connectionContext + Create_database() ICreate_databaseContext + Create_dynamic_table() ICreate_dynamic_tableContext + Create_external_function() ICreate_external_functionContext + Create_external_table() ICreate_external_tableContext + Create_failover_group() ICreate_failover_groupContext + Create_file_format() ICreate_file_formatContext + Create_function() ICreate_functionContext + Create_managed_account() ICreate_managed_accountContext + Create_masking_policy() ICreate_masking_policyContext + Create_materialized_view() ICreate_materialized_viewContext + Create_network_policy() ICreate_network_policyContext + Create_notification_integration() ICreate_notification_integrationContext + Create_pipe() ICreate_pipeContext + Create_procedure() ICreate_procedureContext + Create_replication_group() ICreate_replication_groupContext + Create_resource_monitor() ICreate_resource_monitorContext + Create_role() ICreate_roleContext + Create_row_access_policy() ICreate_row_access_policyContext + Create_schema() ICreate_schemaContext + Create_security_integration_external_oauth() ICreate_security_integration_external_oauthContext + Create_security_integration_snowflake_oauth() ICreate_security_integration_snowflake_oauthContext + Create_security_integration_saml2() ICreate_security_integration_saml2Context + Create_security_integration_scim() ICreate_security_integration_scimContext + Create_sequence() ICreate_sequenceContext + Create_session_policy() ICreate_session_policyContext + Create_share() ICreate_shareContext + Create_stage() ICreate_stageContext + Create_storage_integration() ICreate_storage_integrationContext + Create_stream() ICreate_streamContext + Create_table() ICreate_tableContext + Create_table_as_select() ICreate_table_as_selectContext + Create_tag() ICreate_tagContext + Create_task() ICreate_taskContext + Create_user() ICreate_userContext + Create_view() ICreate_viewContext + Create_warehouse() ICreate_warehouseContext + + // IsCreate_commandContext differentiates from other interfaces. + IsCreate_commandContext() +} + +type Create_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_commandContext() *Create_commandContext { + var p = new(Create_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_command + return p +} + +func InitEmptyCreate_commandContext(p *Create_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_command +} + +func (*Create_commandContext) IsCreate_commandContext() {} + +func NewCreate_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_commandContext { + var p = new(Create_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_command + + return p +} + +func (s *Create_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_commandContext) Create_account() ICreate_accountContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_accountContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_accountContext) +} + +func (s *Create_commandContext) Create_alert() ICreate_alertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_alertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_alertContext) +} + +func (s *Create_commandContext) Create_api_integration() ICreate_api_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_api_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_api_integrationContext) +} + +func (s *Create_commandContext) Create_object_clone() ICreate_object_cloneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_object_cloneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_object_cloneContext) +} + +func (s *Create_commandContext) Create_connection() ICreate_connectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_connectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_connectionContext) +} + +func (s *Create_commandContext) Create_database() ICreate_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_databaseContext) +} + +func (s *Create_commandContext) Create_dynamic_table() ICreate_dynamic_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_dynamic_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_dynamic_tableContext) +} + +func (s *Create_commandContext) Create_external_function() ICreate_external_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_external_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_external_functionContext) +} + +func (s *Create_commandContext) Create_external_table() ICreate_external_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_external_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_external_tableContext) +} + +func (s *Create_commandContext) Create_failover_group() ICreate_failover_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_failover_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_failover_groupContext) +} + +func (s *Create_commandContext) Create_file_format() ICreate_file_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_file_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_file_formatContext) +} + +func (s *Create_commandContext) Create_function() ICreate_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_functionContext) +} + +func (s *Create_commandContext) Create_managed_account() ICreate_managed_accountContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_managed_accountContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_managed_accountContext) +} + +func (s *Create_commandContext) Create_masking_policy() ICreate_masking_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_masking_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_masking_policyContext) +} + +func (s *Create_commandContext) Create_materialized_view() ICreate_materialized_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_materialized_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_materialized_viewContext) +} + +func (s *Create_commandContext) Create_network_policy() ICreate_network_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_network_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_network_policyContext) +} + +func (s *Create_commandContext) Create_notification_integration() ICreate_notification_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_notification_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_notification_integrationContext) +} + +func (s *Create_commandContext) Create_pipe() ICreate_pipeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_pipeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_pipeContext) +} + +func (s *Create_commandContext) Create_procedure() ICreate_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_procedureContext) +} + +func (s *Create_commandContext) Create_replication_group() ICreate_replication_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_replication_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_replication_groupContext) +} + +func (s *Create_commandContext) Create_resource_monitor() ICreate_resource_monitorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_resource_monitorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_resource_monitorContext) +} + +func (s *Create_commandContext) Create_role() ICreate_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_roleContext) +} + +func (s *Create_commandContext) Create_row_access_policy() ICreate_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_row_access_policyContext) +} + +func (s *Create_commandContext) Create_schema() ICreate_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_schemaContext) +} + +func (s *Create_commandContext) Create_security_integration_external_oauth() ICreate_security_integration_external_oauthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_security_integration_external_oauthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_security_integration_external_oauthContext) +} + +func (s *Create_commandContext) Create_security_integration_snowflake_oauth() ICreate_security_integration_snowflake_oauthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_security_integration_snowflake_oauthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_security_integration_snowflake_oauthContext) +} + +func (s *Create_commandContext) Create_security_integration_saml2() ICreate_security_integration_saml2Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_security_integration_saml2Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_security_integration_saml2Context) +} + +func (s *Create_commandContext) Create_security_integration_scim() ICreate_security_integration_scimContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_security_integration_scimContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_security_integration_scimContext) +} + +func (s *Create_commandContext) Create_sequence() ICreate_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_sequenceContext) +} + +func (s *Create_commandContext) Create_session_policy() ICreate_session_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_session_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_session_policyContext) +} + +func (s *Create_commandContext) Create_share() ICreate_shareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_shareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_shareContext) +} + +func (s *Create_commandContext) Create_stage() ICreate_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_stageContext) +} + +func (s *Create_commandContext) Create_storage_integration() ICreate_storage_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_storage_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_storage_integrationContext) +} + +func (s *Create_commandContext) Create_stream() ICreate_streamContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_streamContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_streamContext) +} + +func (s *Create_commandContext) Create_table() ICreate_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tableContext) +} + +func (s *Create_commandContext) Create_table_as_select() ICreate_table_as_selectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_table_as_selectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_table_as_selectContext) +} + +func (s *Create_commandContext) Create_tag() ICreate_tagContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tagContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tagContext) +} + +func (s *Create_commandContext) Create_task() ICreate_taskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_taskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_taskContext) +} + +func (s *Create_commandContext) Create_user() ICreate_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_userContext) +} + +func (s *Create_commandContext) Create_view() ICreate_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_viewContext) +} + +func (s *Create_commandContext) Create_warehouse() ICreate_warehouseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_warehouseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_warehouseContext) +} + +func (s *Create_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_command(s) + } +} + +func (s *Create_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_command(s) + } +} + +func (s *Create_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_command() (localctx ICreate_commandContext) { + localctx = NewCreate_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, SnowflakeParserRULE_create_command) + p.SetState(6034) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 649, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5993) + p.Create_account() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5994) + p.Create_alert() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5995) + p.Create_api_integration() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5996) + p.Create_object_clone() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5997) + p.Create_connection() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5998) + p.Create_database() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5999) + p.Create_dynamic_table() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6000) + p.Create_external_function() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6001) + p.Create_external_table() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6002) + p.Create_failover_group() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(6003) + p.Create_file_format() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(6004) + p.Create_function() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(6005) + p.Create_managed_account() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(6006) + p.Create_masking_policy() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(6007) + p.Create_materialized_view() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(6008) + p.Create_network_policy() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(6009) + p.Create_notification_integration() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(6010) + p.Create_pipe() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(6011) + p.Create_procedure() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(6012) + p.Create_replication_group() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(6013) + p.Create_resource_monitor() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(6014) + p.Create_role() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(6015) + p.Create_row_access_policy() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(6016) + p.Create_schema() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(6017) + p.Create_security_integration_external_oauth() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(6018) + p.Create_security_integration_snowflake_oauth() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(6019) + p.Create_security_integration_saml2() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(6020) + p.Create_security_integration_scim() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(6021) + p.Create_sequence() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(6022) + p.Create_session_policy() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(6023) + p.Create_share() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(6024) + p.Create_stage() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(6025) + p.Create_storage_integration() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(6026) + p.Create_stream() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(6027) + p.Create_table() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(6028) + p.Create_table_as_select() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(6029) + p.Create_tag() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(6030) + p.Create_task() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(6031) + p.Create_user() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(6032) + p.Create_view() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(6033) + p.Create_warehouse() + } + + 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_accountContext is an interface to support dynamic dispatch. +type ICreate_accountContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ADMIN_NAME() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + ADMIN_PASSWORD() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + EMAIL() antlr.TerminalNode + EDITION() antlr.TerminalNode + STANDARD() antlr.TerminalNode + ENTERPRISE() antlr.TerminalNode + BUSINESS_CRITICAL() antlr.TerminalNode + FIRST_NAME() antlr.TerminalNode + LAST_NAME() antlr.TerminalNode + MUST_CHANGE_PASSWORD() antlr.TerminalNode + True_false() ITrue_falseContext + REGION_GROUP() antlr.TerminalNode + Region_group_id() IRegion_group_idContext + REGION() antlr.TerminalNode + Snowflake_region_id() ISnowflake_region_idContext + Comment_clause() IComment_clauseContext + + // IsCreate_accountContext differentiates from other interfaces. + IsCreate_accountContext() +} + +type Create_accountContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_accountContext() *Create_accountContext { + var p = new(Create_accountContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_account + return p +} + +func InitEmptyCreate_accountContext(p *Create_accountContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_account +} + +func (*Create_accountContext) IsCreate_accountContext() {} + +func NewCreate_accountContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_accountContext { + var p = new(Create_accountContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_account + + return p +} + +func (s *Create_accountContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_accountContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_accountContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Create_accountContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_accountContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_accountContext) ADMIN_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADMIN_NAME, 0) +} + +func (s *Create_accountContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_accountContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_accountContext) ADMIN_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADMIN_PASSWORD, 0) +} + +func (s *Create_accountContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_accountContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_accountContext) EMAIL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEMAIL, 0) +} + +func (s *Create_accountContext) EDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEDITION, 0) +} + +func (s *Create_accountContext) STANDARD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTANDARD, 0) +} + +func (s *Create_accountContext) ENTERPRISE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENTERPRISE, 0) +} + +func (s *Create_accountContext) BUSINESS_CRITICAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBUSINESS_CRITICAL, 0) +} + +func (s *Create_accountContext) FIRST_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIRST_NAME, 0) +} + +func (s *Create_accountContext) LAST_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST_NAME, 0) +} + +func (s *Create_accountContext) MUST_CHANGE_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMUST_CHANGE_PASSWORD, 0) +} + +func (s *Create_accountContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_accountContext) REGION_GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREGION_GROUP, 0) +} + +func (s *Create_accountContext) Region_group_id() IRegion_group_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegion_group_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegion_group_idContext) +} + +func (s *Create_accountContext) REGION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREGION, 0) +} + +func (s *Create_accountContext) Snowflake_region_id() ISnowflake_region_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISnowflake_region_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISnowflake_region_idContext) +} + +func (s *Create_accountContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_accountContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_accountContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_accountContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_account(s) + } +} + +func (s *Create_accountContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_account(s) + } +} + +func (s *Create_accountContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_account(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_account() (localctx ICreate_accountContext) { + localctx = NewCreate_accountContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, SnowflakeParserRULE_create_account) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6036) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6037) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6038) + p.Id_() + } + { + p.SetState(6039) + p.Match(SnowflakeParserADMIN_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6040) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6041) + p.Id_() + } + { + p.SetState(6042) + p.Match(SnowflakeParserADMIN_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6043) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6044) + p.String_() + } + p.SetState(6048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFIRST_NAME { + { + p.SetState(6045) + p.Match(SnowflakeParserFIRST_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6046) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6047) + p.Id_() + } + + } + p.SetState(6053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLAST_NAME { + { + p.SetState(6050) + p.Match(SnowflakeParserLAST_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6051) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6052) + p.Id_() + } + + } + { + p.SetState(6055) + p.Match(SnowflakeParserEMAIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6056) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6057) + p.String_() + } + p.SetState(6061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMUST_CHANGE_PASSWORD { + { + p.SetState(6058) + p.Match(SnowflakeParserMUST_CHANGE_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6059) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6060) + p.True_false() + } + + } + { + p.SetState(6063) + p.Match(SnowflakeParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6064) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6065) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserBUSINESS_CRITICAL || _la == SnowflakeParserENTERPRISE || _la == SnowflakeParserSTANDARD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREGION_GROUP { + { + p.SetState(6066) + p.Match(SnowflakeParserREGION_GROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6067) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6068) + p.Region_group_id() + } + + } + p.SetState(6074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREGION { + { + p.SetState(6071) + p.Match(SnowflakeParserREGION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6072) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6073) + p.Snowflake_region_id() + } + + } + p.SetState(6077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6076) + p.Comment_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 +} + +// ICreate_alertContext is an interface to support dynamic dispatch. +type ICreate_alertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ALERT() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + WAREHOUSE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + SCHEDULE() antlr.TerminalNode + String_() IStringContext + IF() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + EXISTS() antlr.TerminalNode + Alert_condition() IAlert_conditionContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + THEN() antlr.TerminalNode + Alert_action() IAlert_actionContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + + // IsCreate_alertContext differentiates from other interfaces. + IsCreate_alertContext() +} + +type Create_alertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_alertContext() *Create_alertContext { + var p = new(Create_alertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_alert + return p +} + +func InitEmptyCreate_alertContext(p *Create_alertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_alert +} + +func (*Create_alertContext) IsCreate_alertContext() {} + +func NewCreate_alertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_alertContext { + var p = new(Create_alertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_alert + + return p +} + +func (s *Create_alertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_alertContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_alertContext) ALERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERT, 0) +} + +func (s *Create_alertContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_alertContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_alertContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Create_alertContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_alertContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_alertContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEDULE, 0) +} + +func (s *Create_alertContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_alertContext) IF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIF, 0) +} + +func (s *Create_alertContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_alertContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_alertContext) EXISTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXISTS, 0) +} + +func (s *Create_alertContext) Alert_condition() IAlert_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlert_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlert_conditionContext) +} + +func (s *Create_alertContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_alertContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_alertContext) THEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTHEN, 0) +} + +func (s *Create_alertContext) Alert_action() IAlert_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlert_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlert_actionContext) +} + +func (s *Create_alertContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_alertContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_alertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_alertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_alertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_alert(s) + } +} + +func (s *Create_alertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_alert(s) + } +} + +func (s *Create_alertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_alert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_alert() (localctx ICreate_alertContext) { + localctx = NewCreate_alertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, SnowflakeParserRULE_create_alert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6079) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6080) + p.Or_replace() + } + + } + { + p.SetState(6083) + p.Match(SnowflakeParserALERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6085) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 657, p.GetParserRuleContext()) == 1 { + { + p.SetState(6084) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6087) + p.Id_() + } + { + p.SetState(6088) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6089) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6090) + p.Id_() + } + { + p.SetState(6091) + p.Match(SnowflakeParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6092) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6093) + p.String_() + } + { + p.SetState(6094) + p.Match(SnowflakeParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6095) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6096) + p.Match(SnowflakeParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6097) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6098) + p.Alert_condition() + } + { + p.SetState(6099) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6100) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6101) + p.Match(SnowflakeParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6102) + p.Alert_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 +} + +// IAlert_conditionContext is an interface to support dynamic dispatch. +type IAlert_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_statement() ISelect_statementContext + Show_command() IShow_commandContext + Call() ICallContext + + // IsAlert_conditionContext differentiates from other interfaces. + IsAlert_conditionContext() +} + +type Alert_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlert_conditionContext() *Alert_conditionContext { + var p = new(Alert_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alert_condition + return p +} + +func InitEmptyAlert_conditionContext(p *Alert_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alert_condition +} + +func (*Alert_conditionContext) IsAlert_conditionContext() {} + +func NewAlert_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alert_conditionContext { + var p = new(Alert_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alert_condition + + return p +} + +func (s *Alert_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alert_conditionContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Alert_conditionContext) Show_command() IShow_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_commandContext) +} + +func (s *Alert_conditionContext) Call() ICallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICallContext) +} + +func (s *Alert_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alert_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alert_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlert_condition(s) + } +} + +func (s *Alert_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlert_condition(s) + } +} + +func (s *Alert_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlert_condition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alert_condition() (localctx IAlert_conditionContext) { + localctx = NewAlert_conditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, SnowflakeParserRULE_alert_condition) + p.SetState(6107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSELECT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6104) + p.Select_statement() + } + + case SnowflakeParserSHOW: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6105) + p.Show_command() + } + + case SnowflakeParserCALL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6106) + p.Call() + } + + 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 +} + +// IAlert_actionContext is an interface to support dynamic dispatch. +type IAlert_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_command() ISql_commandContext + + // IsAlert_actionContext differentiates from other interfaces. + IsAlert_actionContext() +} + +type Alert_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlert_actionContext() *Alert_actionContext { + var p = new(Alert_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alert_action + return p +} + +func InitEmptyAlert_actionContext(p *Alert_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alert_action +} + +func (*Alert_actionContext) IsAlert_actionContext() {} + +func NewAlert_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alert_actionContext { + var p = new(Alert_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alert_action + + return p +} + +func (s *Alert_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alert_actionContext) Sql_command() ISql_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_commandContext) +} + +func (s *Alert_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alert_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alert_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlert_action(s) + } +} + +func (s *Alert_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlert_action(s) + } +} + +func (s *Alert_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlert_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alert_action() (localctx IAlert_actionContext) { + localctx = NewAlert_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, SnowflakeParserRULE_alert_action) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6109) + p.Sql_command() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_api_integrationContext is an interface to support dynamic dispatch. +type ICreate_api_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + API() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + API_PROVIDER() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + API_AWS_ROLE_ARN() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + API_ALLOWED_PREFIXES() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + ENABLED() antlr.TerminalNode + True_false() ITrue_falseContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + API_KEY() antlr.TerminalNode + API_BLOCKED_PREFIXES() antlr.TerminalNode + Comment_clause() IComment_clauseContext + AZURE_TENANT_ID() antlr.TerminalNode + AZURE_AD_APPLICATION_ID() antlr.TerminalNode + GOOGLE_AUDIENCE() antlr.TerminalNode + + // IsCreate_api_integrationContext differentiates from other interfaces. + IsCreate_api_integrationContext() +} + +type Create_api_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_api_integrationContext() *Create_api_integrationContext { + var p = new(Create_api_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_api_integration + return p +} + +func InitEmptyCreate_api_integrationContext(p *Create_api_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_api_integration +} + +func (*Create_api_integrationContext) IsCreate_api_integrationContext() {} + +func NewCreate_api_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_api_integrationContext { + var p = new(Create_api_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_api_integration + + return p +} + +func (s *Create_api_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_api_integrationContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_api_integrationContext) API() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI, 0) +} + +func (s *Create_api_integrationContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Create_api_integrationContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_api_integrationContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_api_integrationContext) API_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_PROVIDER, 0) +} + +func (s *Create_api_integrationContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_api_integrationContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_api_integrationContext) API_AWS_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_AWS_ROLE_ARN, 0) +} + +func (s *Create_api_integrationContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_api_integrationContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_api_integrationContext) API_ALLOWED_PREFIXES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_ALLOWED_PREFIXES, 0) +} + +func (s *Create_api_integrationContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_api_integrationContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_api_integrationContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_api_integrationContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_api_integrationContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Create_api_integrationContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_api_integrationContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_api_integrationContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_api_integrationContext) API_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_KEY, 0) +} + +func (s *Create_api_integrationContext) API_BLOCKED_PREFIXES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_BLOCKED_PREFIXES, 0) +} + +func (s *Create_api_integrationContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_api_integrationContext) AZURE_TENANT_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_TENANT_ID, 0) +} + +func (s *Create_api_integrationContext) AZURE_AD_APPLICATION_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_AD_APPLICATION_ID, 0) +} + +func (s *Create_api_integrationContext) GOOGLE_AUDIENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGOOGLE_AUDIENCE, 0) +} + +func (s *Create_api_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_api_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_api_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_api_integration(s) + } +} + +func (s *Create_api_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_api_integration(s) + } +} + +func (s *Create_api_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_api_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_api_integration() (localctx ICreate_api_integrationContext) { + localctx = NewCreate_api_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, SnowflakeParserRULE_create_api_integration) + var _la int + + p.SetState(6225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 671, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6111) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6112) + p.Or_replace() + } + + } + { + p.SetState(6115) + p.Match(SnowflakeParserAPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6116) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6118) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 660, p.GetParserRuleContext()) == 1 { + { + p.SetState(6117) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6120) + p.Id_() + } + { + p.SetState(6121) + p.Match(SnowflakeParserAPI_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6122) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(6123) + p.Id_() + } + + { + p.SetState(6124) + p.Match(SnowflakeParserAPI_AWS_ROLE_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6125) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6126) + p.String_() + } + p.SetState(6130) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_KEY { + { + p.SetState(6127) + p.Match(SnowflakeParserAPI_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6128) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6129) + p.String_() + } + + } + { + p.SetState(6132) + p.Match(SnowflakeParserAPI_ALLOWED_PREFIXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6133) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6134) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6135) + p.String_() + } + { + p.SetState(6136) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_BLOCKED_PREFIXES { + { + p.SetState(6137) + p.Match(SnowflakeParserAPI_BLOCKED_PREFIXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6138) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6139) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6140) + p.String_() + } + { + p.SetState(6141) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6145) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6146) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6147) + p.True_false() + } + p.SetState(6149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6148) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6151) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6152) + p.Or_replace() + } + + } + { + p.SetState(6155) + p.Match(SnowflakeParserAPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6156) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6158) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 665, p.GetParserRuleContext()) == 1 { + { + p.SetState(6157) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6160) + p.Id_() + } + { + p.SetState(6161) + p.Match(SnowflakeParserAPI_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6162) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6163) + p.Id_() + } + { + p.SetState(6164) + p.Match(SnowflakeParserAZURE_TENANT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6165) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6166) + p.String_() + } + { + p.SetState(6167) + p.Match(SnowflakeParserAZURE_AD_APPLICATION_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6168) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6169) + p.String_() + } + p.SetState(6173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_KEY { + { + p.SetState(6170) + p.Match(SnowflakeParserAPI_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6171) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6172) + p.String_() + } + + } + { + p.SetState(6175) + p.Match(SnowflakeParserAPI_ALLOWED_PREFIXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6176) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6177) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6178) + p.String_() + } + { + p.SetState(6179) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6186) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_BLOCKED_PREFIXES { + { + p.SetState(6180) + p.Match(SnowflakeParserAPI_BLOCKED_PREFIXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6181) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6182) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6183) + p.String_() + } + { + p.SetState(6184) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6188) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6189) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6190) + p.True_false() + } + p.SetState(6192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6191) + p.Comment_clause() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6194) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6195) + p.Or_replace() + } + { + p.SetState(6196) + p.Match(SnowflakeParserAPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6197) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6198) + p.If_not_exists() + } + { + p.SetState(6199) + p.Id_() + } + { + p.SetState(6200) + p.Match(SnowflakeParserAPI_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6201) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6202) + p.Id_() + } + { + p.SetState(6203) + p.Match(SnowflakeParserGOOGLE_AUDIENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6204) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6205) + p.String_() + } + { + p.SetState(6206) + p.Match(SnowflakeParserAPI_ALLOWED_PREFIXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6207) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6208) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6209) + p.String_() + } + { + p.SetState(6210) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI_BLOCKED_PREFIXES { + { + p.SetState(6211) + p.Match(SnowflakeParserAPI_BLOCKED_PREFIXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6212) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6213) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6214) + p.String_() + } + { + p.SetState(6215) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6219) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6220) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6221) + p.True_false() + } + p.SetState(6223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6222) + p.Comment_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 +} + +// ICreate_object_cloneContext is an interface to support dynamic dispatch. +type ICreate_object_cloneContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + CLONE() antlr.TerminalNode + AllObject_name() []IObject_nameContext + Object_name(i int) IObject_nameContext + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + TABLE() antlr.TerminalNode + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + At_before1() IAt_before1Context + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + ASSOC() antlr.TerminalNode + String_() IStringContext + OFFSET() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + STAGE() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + STREAM() antlr.TerminalNode + TASK() antlr.TerminalNode + + // IsCreate_object_cloneContext differentiates from other interfaces. + IsCreate_object_cloneContext() +} + +type Create_object_cloneContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_object_cloneContext() *Create_object_cloneContext { + var p = new(Create_object_cloneContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_object_clone + return p +} + +func InitEmptyCreate_object_cloneContext(p *Create_object_cloneContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_object_clone +} + +func (*Create_object_cloneContext) IsCreate_object_cloneContext() {} + +func NewCreate_object_cloneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_object_cloneContext { + var p = new(Create_object_cloneContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_object_clone + + return p +} + +func (s *Create_object_cloneContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_object_cloneContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_object_cloneContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_object_cloneContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_object_cloneContext) CLONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLONE, 0) +} + +func (s *Create_object_cloneContext) AllObject_name() []IObject_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_nameContext); ok { + len++ + } + } + + tst := make([]IObject_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_nameContext); ok { + tst[i] = t.(IObject_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_object_cloneContext) Object_name(i int) IObject_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_object_cloneContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Create_object_cloneContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Create_object_cloneContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Create_object_cloneContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_object_cloneContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_object_cloneContext) At_before1() IAt_before1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAt_before1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAt_before1Context) +} + +func (s *Create_object_cloneContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Create_object_cloneContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Create_object_cloneContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP, 0) +} + +func (s *Create_object_cloneContext) ASSOC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASSOC, 0) +} + +func (s *Create_object_cloneContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_object_cloneContext) OFFSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFFSET, 0) +} + +func (s *Create_object_cloneContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT, 0) +} + +func (s *Create_object_cloneContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Create_object_cloneContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Create_object_cloneContext) FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT, 0) +} + +func (s *Create_object_cloneContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 0) +} + +func (s *Create_object_cloneContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Create_object_cloneContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Create_object_cloneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_object_cloneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_object_cloneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_object_clone(s) + } +} + +func (s *Create_object_cloneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_object_clone(s) + } +} + +func (s *Create_object_cloneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_object_clone(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_object_clone() (localctx ICreate_object_cloneContext) { + localctx = NewCreate_object_cloneContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, SnowflakeParserRULE_create_object_clone) + var _la int + + p.SetState(6274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 679, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6227) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6228) + p.Or_replace() + } + + } + { + p.SetState(6231) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDATABASE || _la == SnowflakeParserSCHEMA || _la == SnowflakeParserTABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6233) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 673, p.GetParserRuleContext()) == 1 { + { + p.SetState(6232) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6235) + p.Id_() + } + { + p.SetState(6236) + p.Match(SnowflakeParserCLONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6237) + p.Object_name() + } + p.SetState(6253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAT_KEYWORD || _la == SnowflakeParserBEFORE { + { + p.SetState(6238) + p.At_before1() + } + { + p.SetState(6239) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserTIMESTAMP: + { + p.SetState(6240) + p.Match(SnowflakeParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6241) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6242) + p.String_() + } + + case SnowflakeParserOFFSET: + { + p.SetState(6243) + p.Match(SnowflakeParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6244) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6245) + p.String_() + } + + case SnowflakeParserSTATEMENT: + { + p.SetState(6246) + p.Match(SnowflakeParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6247) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6248) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6251) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6255) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6256) + p.Or_replace() + } + + } + p.SetState(6265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTAGE: + { + p.SetState(6259) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFILE: + { + p.SetState(6260) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6261) + p.Match(SnowflakeParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSEQUENCE: + { + p.SetState(6262) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTREAM: + { + p.SetState(6263) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTASK: + { + p.SetState(6264) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6268) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 678, p.GetParserRuleContext()) == 1 { + { + p.SetState(6267) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6270) + p.Object_name() + } + { + p.SetState(6271) + p.Match(SnowflakeParserCLONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6272) + p.Object_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 +} + +// ICreate_connectionContext is an interface to support dynamic dispatch. +type ICreate_connectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + If_not_exists() IIf_not_existsContext + AS() antlr.TerminalNode + REPLICA() antlr.TerminalNode + OF() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsCreate_connectionContext differentiates from other interfaces. + IsCreate_connectionContext() +} + +type Create_connectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_connectionContext() *Create_connectionContext { + var p = new(Create_connectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_connection + return p +} + +func InitEmptyCreate_connectionContext(p *Create_connectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_connection +} + +func (*Create_connectionContext) IsCreate_connectionContext() {} + +func NewCreate_connectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_connectionContext { + var p = new(Create_connectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_connection + + return p +} + +func (s *Create_connectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_connectionContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_connectionContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONNECTION, 0) +} + +func (s *Create_connectionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_connectionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_connectionContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_connectionContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_connectionContext) REPLICA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICA, 0) +} + +func (s *Create_connectionContext) OF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOF, 0) +} + +func (s *Create_connectionContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserDOT) +} + +func (s *Create_connectionContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, i) +} + +func (s *Create_connectionContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_connectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_connectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_connectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_connection(s) + } +} + +func (s *Create_connectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_connection(s) + } +} + +func (s *Create_connectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_connection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_connection() (localctx ICreate_connectionContext) { + localctx = NewCreate_connectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, SnowflakeParserRULE_create_connection) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6276) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6277) + p.Match(SnowflakeParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6279) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 680, p.GetParserRuleContext()) == 1 { + { + p.SetState(6278) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6281) + p.Id_() + } + p.SetState(6296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserEOF, SnowflakeParserCOMMENT, SnowflakeParserSEMI: + p.SetState(6283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6282) + p.Comment_clause() + } + + } + + case SnowflakeParserAS: + { + p.SetState(6285) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6286) + p.Match(SnowflakeParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6287) + p.Match(SnowflakeParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6288) + p.Id_() + } + { + p.SetState(6289) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6290) + p.Id_() + } + { + p.SetState(6291) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6292) + p.Id_() + } + p.SetState(6294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6293) + p.Comment_clause() + } + + } + + 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 +} + +// ICreate_databaseContext is an interface to support dynamic dispatch. +type ICreate_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + Or_replace() IOr_replaceContext + TRANSIENT() antlr.TerminalNode + If_not_exists() IIf_not_existsContext + Clone_at_before() IClone_at_beforeContext + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + Default_ddl_collation() IDefault_ddl_collationContext + With_tags() IWith_tagsContext + Comment_clause() IComment_clauseContext + + // IsCreate_databaseContext differentiates from other interfaces. + IsCreate_databaseContext() +} + +type Create_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_databaseContext() *Create_databaseContext { + var p = new(Create_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_database + return p +} + +func InitEmptyCreate_databaseContext(p *Create_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_database +} + +func (*Create_databaseContext) IsCreate_databaseContext() {} + +func NewCreate_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_databaseContext { + var p = new(Create_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_database + + return p +} + +func (s *Create_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_databaseContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Create_databaseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_databaseContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_databaseContext) TRANSIENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSIENT, 0) +} + +func (s *Create_databaseContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_databaseContext) Clone_at_before() IClone_at_beforeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClone_at_beforeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClone_at_beforeContext) +} + +func (s *Create_databaseContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Create_databaseContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_databaseContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_databaseContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Create_databaseContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Create_databaseContext) Default_ddl_collation() IDefault_ddl_collationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_ddl_collationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_ddl_collationContext) +} + +func (s *Create_databaseContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Create_databaseContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_database(s) + } +} + +func (s *Create_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_database(s) + } +} + +func (s *Create_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_database() (localctx ICreate_databaseContext) { + localctx = NewCreate_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, SnowflakeParserRULE_create_database) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6298) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6299) + p.Or_replace() + } + + } + p.SetState(6303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTRANSIENT { + { + p.SetState(6302) + p.Match(SnowflakeParserTRANSIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6305) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6307) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 686, p.GetParserRuleContext()) == 1 { + { + p.SetState(6306) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6309) + p.Id_() + } + p.SetState(6311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCLONE { + { + p.SetState(6310) + p.Clone_at_before() + } + + } + p.SetState(6316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDATA_RETENTION_TIME_IN_DAYS { + { + p.SetState(6313) + p.Match(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6314) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6315) + p.Num() + } + + } + p.SetState(6321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS { + { + p.SetState(6318) + p.Match(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6319) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6320) + p.Num() + } + + } + p.SetState(6324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDEFAULT_DDL_COLLATION_ { + { + p.SetState(6323) + p.Default_ddl_collation() + } + + } + p.SetState(6327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(6326) + p.With_tags() + } + + } + p.SetState(6330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6329) + p.Comment_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 +} + +// ICreate_dynamic_tableContext is an interface to support dynamic dispatch. +type ICreate_dynamic_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetWh returns the wh rule contexts. + GetWh() IId_Context + + // SetWh sets the wh rule contexts. + SetWh(IId_Context) + + // Getter signatures + CREATE() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + TARGET_LAG() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + AS() antlr.TerminalNode + Query_statement() IQuery_statementContext + String_() IStringContext + DOWNSTREAM() antlr.TerminalNode + Or_replace() IOr_replaceContext + + // IsCreate_dynamic_tableContext differentiates from other interfaces. + IsCreate_dynamic_tableContext() +} + +type Create_dynamic_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + wh IId_Context +} + +func NewEmptyCreate_dynamic_tableContext() *Create_dynamic_tableContext { + var p = new(Create_dynamic_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_dynamic_table + return p +} + +func InitEmptyCreate_dynamic_tableContext(p *Create_dynamic_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_dynamic_table +} + +func (*Create_dynamic_tableContext) IsCreate_dynamic_tableContext() {} + +func NewCreate_dynamic_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_dynamic_tableContext { + var p = new(Create_dynamic_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_dynamic_table + + return p +} + +func (s *Create_dynamic_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_dynamic_tableContext) GetWh() IId_Context { return s.wh } + +func (s *Create_dynamic_tableContext) SetWh(v IId_Context) { s.wh = v } + +func (s *Create_dynamic_tableContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_dynamic_tableContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDYNAMIC, 0) +} + +func (s *Create_dynamic_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Create_dynamic_tableContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_dynamic_tableContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_dynamic_tableContext) TARGET_LAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTARGET_LAG, 0) +} + +func (s *Create_dynamic_tableContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_dynamic_tableContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_dynamic_tableContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Create_dynamic_tableContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_dynamic_tableContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *Create_dynamic_tableContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_dynamic_tableContext) DOWNSTREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOWNSTREAM, 0) +} + +func (s *Create_dynamic_tableContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_dynamic_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_dynamic_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_dynamic_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_dynamic_table(s) + } +} + +func (s *Create_dynamic_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_dynamic_table(s) + } +} + +func (s *Create_dynamic_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_dynamic_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_dynamic_table() (localctx ICreate_dynamic_tableContext) { + localctx = NewCreate_dynamic_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, SnowflakeParserRULE_create_dynamic_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6332) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6333) + p.Or_replace() + } + + } + { + p.SetState(6336) + p.Match(SnowflakeParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6337) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6338) + p.Id_() + } + { + p.SetState(6339) + p.Match(SnowflakeParserTARGET_LAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6340) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(6341) + p.String_() + } + + case SnowflakeParserDOWNSTREAM: + { + p.SetState(6342) + p.Match(SnowflakeParserDOWNSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6345) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6346) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6347) + + var _x = p.Id_() + + localctx.(*Create_dynamic_tableContext).wh = _x + } + { + p.SetState(6348) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6349) + p.Query_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClone_at_beforeContext is an interface to support dynamic dispatch. +type IClone_at_beforeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLONE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + At_before1() IAt_before1Context + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + ASSOC() antlr.TerminalNode + String_() IStringContext + OFFSET() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + + // IsClone_at_beforeContext differentiates from other interfaces. + IsClone_at_beforeContext() +} + +type Clone_at_beforeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClone_at_beforeContext() *Clone_at_beforeContext { + var p = new(Clone_at_beforeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_clone_at_before + return p +} + +func InitEmptyClone_at_beforeContext(p *Clone_at_beforeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_clone_at_before +} + +func (*Clone_at_beforeContext) IsClone_at_beforeContext() {} + +func NewClone_at_beforeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clone_at_beforeContext { + var p = new(Clone_at_beforeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_clone_at_before + + return p +} + +func (s *Clone_at_beforeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clone_at_beforeContext) CLONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLONE, 0) +} + +func (s *Clone_at_beforeContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Clone_at_beforeContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Clone_at_beforeContext) At_before1() IAt_before1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAt_before1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAt_before1Context) +} + +func (s *Clone_at_beforeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Clone_at_beforeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Clone_at_beforeContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP, 0) +} + +func (s *Clone_at_beforeContext) ASSOC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASSOC, 0) +} + +func (s *Clone_at_beforeContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Clone_at_beforeContext) OFFSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFFSET, 0) +} + +func (s *Clone_at_beforeContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT, 0) +} + +func (s *Clone_at_beforeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clone_at_beforeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clone_at_beforeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterClone_at_before(s) + } +} + +func (s *Clone_at_beforeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitClone_at_before(s) + } +} + +func (s *Clone_at_beforeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitClone_at_before(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Clone_at_before() (localctx IClone_at_beforeContext) { + localctx = NewClone_at_beforeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, SnowflakeParserRULE_clone_at_before) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6351) + p.Match(SnowflakeParserCLONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6352) + p.Id_() + } + p.SetState(6368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAT_KEYWORD || _la == SnowflakeParserBEFORE { + { + p.SetState(6353) + p.At_before1() + } + { + p.SetState(6354) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserTIMESTAMP: + { + p.SetState(6355) + p.Match(SnowflakeParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6356) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6357) + p.String_() + } + + case SnowflakeParserOFFSET: + { + p.SetState(6358) + p.Match(SnowflakeParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6359) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6360) + p.String_() + } + + case SnowflakeParserSTATEMENT: + { + p.SetState(6361) + p.Match(SnowflakeParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6362) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6363) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6366) + p.Match(SnowflakeParserRR_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 +} + +// IAt_before1Context is an interface to support dynamic dispatch. +type IAt_before1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AT_KEYWORD() antlr.TerminalNode + BEFORE() antlr.TerminalNode + + // IsAt_before1Context differentiates from other interfaces. + IsAt_before1Context() +} + +type At_before1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAt_before1Context() *At_before1Context { + var p = new(At_before1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_at_before1 + return p +} + +func InitEmptyAt_before1Context(p *At_before1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_at_before1 +} + +func (*At_before1Context) IsAt_before1Context() {} + +func NewAt_before1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *At_before1Context { + var p = new(At_before1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_at_before1 + + return p +} + +func (s *At_before1Context) GetParser() antlr.Parser { return s.parser } + +func (s *At_before1Context) AT_KEYWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAT_KEYWORD, 0) +} + +func (s *At_before1Context) BEFORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBEFORE, 0) +} + +func (s *At_before1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *At_before1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *At_before1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAt_before1(s) + } +} + +func (s *At_before1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAt_before1(s) + } +} + +func (s *At_before1Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAt_before1(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) At_before1() (localctx IAt_before1Context) { + localctx = NewAt_before1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, SnowflakeParserRULE_at_before1) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6370) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAT_KEYWORD || _la == SnowflakeParserBEFORE) { + 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 +} + +// IHeader_declContext is an interface to support dynamic dispatch. +type IHeader_declContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllString_() []IStringContext + String_(i int) IStringContext + EQ() antlr.TerminalNode + + // IsHeader_declContext differentiates from other interfaces. + IsHeader_declContext() +} + +type Header_declContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHeader_declContext() *Header_declContext { + var p = new(Header_declContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_header_decl + return p +} + +func InitEmptyHeader_declContext(p *Header_declContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_header_decl +} + +func (*Header_declContext) IsHeader_declContext() {} + +func NewHeader_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Header_declContext { + var p = new(Header_declContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_header_decl + + return p +} + +func (s *Header_declContext) GetParser() antlr.Parser { return s.parser } + +func (s *Header_declContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Header_declContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Header_declContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Header_declContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Header_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Header_declContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterHeader_decl(s) + } +} + +func (s *Header_declContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitHeader_decl(s) + } +} + +func (s *Header_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitHeader_decl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Header_decl() (localctx IHeader_declContext) { + localctx = NewHeader_declContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, SnowflakeParserRULE_header_decl) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6372) + p.String_() + } + { + p.SetState(6373) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6374) + p.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 +} + +// ICompression_typeContext is an interface to support dynamic dispatch. +type ICompression_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NONE() antlr.TerminalNode + GZIP() antlr.TerminalNode + DEFLATE() antlr.TerminalNode + AUTO() antlr.TerminalNode + + // IsCompression_typeContext differentiates from other interfaces. + IsCompression_typeContext() +} + +type Compression_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompression_typeContext() *Compression_typeContext { + var p = new(Compression_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_compression_type + return p +} + +func InitEmptyCompression_typeContext(p *Compression_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_compression_type +} + +func (*Compression_typeContext) IsCompression_typeContext() {} + +func NewCompression_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compression_typeContext { + var p = new(Compression_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_compression_type + + return p +} + +func (s *Compression_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compression_typeContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *Compression_typeContext) GZIP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGZIP, 0) +} + +func (s *Compression_typeContext) DEFLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFLATE, 0) +} + +func (s *Compression_typeContext) AUTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO, 0) +} + +func (s *Compression_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compression_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compression_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCompression_type(s) + } +} + +func (s *Compression_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCompression_type(s) + } +} + +func (s *Compression_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCompression_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Compression_type() (localctx ICompression_typeContext) { + localctx = NewCompression_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, SnowflakeParserRULE_compression_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6376) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAUTO || _la == SnowflakeParserDEFLATE || _la == SnowflakeParserGZIP || _la == SnowflakeParserNONE) { + 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 +} + +// ICompressionContext is an interface to support dynamic dispatch. +type ICompressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPRESSION() antlr.TerminalNode + EQ() antlr.TerminalNode + Compression_type() ICompression_typeContext + + // IsCompressionContext differentiates from other interfaces. + IsCompressionContext() +} + +type CompressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompressionContext() *CompressionContext { + var p = new(CompressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_compression + return p +} + +func InitEmptyCompressionContext(p *CompressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_compression +} + +func (*CompressionContext) IsCompressionContext() {} + +func NewCompressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CompressionContext { + var p = new(CompressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_compression + + return p +} + +func (s *CompressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *CompressionContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMPRESSION, 0) +} + +func (s *CompressionContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *CompressionContext) Compression_type() ICompression_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompression_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompression_typeContext) +} + +func (s *CompressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CompressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CompressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCompression(s) + } +} + +func (s *CompressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCompression(s) + } +} + +func (s *CompressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCompression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Compression() (localctx ICompressionContext) { + localctx = NewCompressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, SnowflakeParserRULE_compression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6378) + p.Match(SnowflakeParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6379) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6380) + p.Compression_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 +} + +// ICreate_external_functionContext is an interface to support dynamic dispatch. +type ICreate_external_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Object_name() IObject_nameContext + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllRETURNS() []antlr.TerminalNode + RETURNS(i int) antlr.TerminalNode + Data_type() IData_typeContext + API_INTEGRATION() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AS() antlr.TerminalNode + String_() IStringContext + Or_replace() IOr_replaceContext + SECURE() antlr.TerminalNode + AllArg_name() []IArg_nameContext + Arg_name(i int) IArg_nameContext + AllArg_data_type() []IArg_data_typeContext + Arg_data_type(i int) IArg_data_typeContext + Null_not_null() INull_not_nullContext + Comment_clause() IComment_clauseContext + HEADERS() antlr.TerminalNode + AllHeader_decl() []IHeader_declContext + Header_decl(i int) IHeader_declContext + CONTEXT_HEADERS() antlr.TerminalNode + MAX_BATCH_ROWS() antlr.TerminalNode + Num() INumContext + Compression() ICompressionContext + REQUEST_TRANSLATOR() antlr.TerminalNode + RESPONSE_TRANSLATOR() antlr.TerminalNode + VOLATILE() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + CALLED() antlr.TerminalNode + ON() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + INPUT() antlr.TerminalNode + STRICT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_external_functionContext differentiates from other interfaces. + IsCreate_external_functionContext() +} + +type Create_external_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_external_functionContext() *Create_external_functionContext { + var p = new(Create_external_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_external_function + return p +} + +func InitEmptyCreate_external_functionContext(p *Create_external_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_external_function +} + +func (*Create_external_functionContext) IsCreate_external_functionContext() {} + +func NewCreate_external_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_functionContext { + var p = new(Create_external_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_external_function + + return p +} + +func (s *Create_external_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_external_functionContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_external_functionContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Create_external_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Create_external_functionContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_external_functionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_external_functionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_external_functionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_external_functionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_external_functionContext) AllRETURNS() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRETURNS) +} + +func (s *Create_external_functionContext) RETURNS(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURNS, i) +} + +func (s *Create_external_functionContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Create_external_functionContext) API_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_INTEGRATION, 0) +} + +func (s *Create_external_functionContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_external_functionContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_external_functionContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_external_functionContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_external_functionContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_external_functionContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_external_functionContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_external_functionContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Create_external_functionContext) AllArg_name() []IArg_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArg_nameContext); ok { + len++ + } + } + + tst := make([]IArg_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArg_nameContext); ok { + tst[i] = t.(IArg_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_external_functionContext) Arg_name(i int) IArg_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArg_nameContext) +} + +func (s *Create_external_functionContext) AllArg_data_type() []IArg_data_typeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArg_data_typeContext); ok { + len++ + } + } + + tst := make([]IArg_data_typeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArg_data_typeContext); ok { + tst[i] = t.(IArg_data_typeContext) + i++ + } + } + + return tst +} + +func (s *Create_external_functionContext) Arg_data_type(i int) IArg_data_typeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_data_typeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArg_data_typeContext) +} + +func (s *Create_external_functionContext) Null_not_null() INull_not_nullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_not_nullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_not_nullContext) +} + +func (s *Create_external_functionContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_external_functionContext) HEADERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHEADERS, 0) +} + +func (s *Create_external_functionContext) AllHeader_decl() []IHeader_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHeader_declContext); ok { + len++ + } + } + + tst := make([]IHeader_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHeader_declContext); ok { + tst[i] = t.(IHeader_declContext) + i++ + } + } + + return tst +} + +func (s *Create_external_functionContext) Header_decl(i int) IHeader_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHeader_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHeader_declContext) +} + +func (s *Create_external_functionContext) CONTEXT_HEADERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTEXT_HEADERS, 0) +} + +func (s *Create_external_functionContext) MAX_BATCH_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_BATCH_ROWS, 0) +} + +func (s *Create_external_functionContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Create_external_functionContext) Compression() ICompressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompressionContext) +} + +func (s *Create_external_functionContext) REQUEST_TRANSLATOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUEST_TRANSLATOR, 0) +} + +func (s *Create_external_functionContext) RESPONSE_TRANSLATOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESPONSE_TRANSLATOR, 0) +} + +func (s *Create_external_functionContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVOLATILE, 0) +} + +func (s *Create_external_functionContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMUTABLE, 0) +} + +func (s *Create_external_functionContext) CALLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCALLED, 0) +} + +func (s *Create_external_functionContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Create_external_functionContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserNULL_) +} + +func (s *Create_external_functionContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, i) +} + +func (s *Create_external_functionContext) INPUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINPUT, 0) +} + +func (s *Create_external_functionContext) STRICT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRICT, 0) +} + +func (s *Create_external_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_external_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_external_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_external_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_external_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_external_function(s) + } +} + +func (s *Create_external_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_external_function(s) + } +} + +func (s *Create_external_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_external_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_external_function() (localctx ICreate_external_functionContext) { + localctx = NewCreate_external_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, SnowflakeParserRULE_create_external_function) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6382) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6384) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6383) + p.Or_replace() + } + + } + p.SetState(6387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURE { + { + p.SetState(6386) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6389) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6390) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6391) + p.Object_name() + } + { + p.SetState(6392) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(6393) + p.Arg_name() + } + { + p.SetState(6394) + p.Arg_data_type() + } + p.SetState(6401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6395) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6396) + p.Arg_name() + } + { + p.SetState(6397) + p.Arg_data_type() + } + + p.SetState(6403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(6406) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6407) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6408) + p.Data_type() + } + p.SetState(6410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT || _la == SnowflakeParserNULL_ { + { + p.SetState(6409) + p.Null_not_null() + } + + } + p.SetState(6424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCALLED: + { + p.SetState(6412) + p.Match(SnowflakeParserCALLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6413) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6414) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6415) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRETURNS, SnowflakeParserSTRICT: + p.SetState(6422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserRETURNS: + { + p.SetState(6416) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6417) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6418) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6419) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6420) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTRICT: + { + p.SetState(6421) + p.Match(SnowflakeParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case SnowflakeParserAPI_INTEGRATION, SnowflakeParserCOMMENT, SnowflakeParserIMMUTABLE, SnowflakeParserVOLATILE: + + default: + } + p.SetState(6427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE { + { + p.SetState(6426) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6429) + p.Comment_clause() + } + + } + { + p.SetState(6432) + p.Match(SnowflakeParserAPI_INTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6433) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6434) + p.Id_() + } + p.SetState(6448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserHEADERS { + { + p.SetState(6435) + p.Match(SnowflakeParserHEADERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6436) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6437) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6438) + p.Header_decl() + } + p.SetState(6443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6439) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6440) + p.Header_decl() + } + + p.SetState(6445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6446) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCONTEXT_HEADERS { + { + p.SetState(6450) + p.Match(SnowflakeParserCONTEXT_HEADERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6451) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6452) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6453) + p.Id_() + } + p.SetState(6458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6454) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6455) + p.Id_() + } + + p.SetState(6460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6461) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMAX_BATCH_ROWS { + { + p.SetState(6465) + p.Match(SnowflakeParserMAX_BATCH_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6466) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6467) + p.Num() + } + + } + p.SetState(6471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMPRESSION { + { + p.SetState(6470) + p.Compression() + } + + } + p.SetState(6476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREQUEST_TRANSLATOR { + { + p.SetState(6473) + p.Match(SnowflakeParserREQUEST_TRANSLATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6474) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6475) + p.Id_() + } + + } + p.SetState(6481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserRESPONSE_TRANSLATOR { + { + p.SetState(6478) + p.Match(SnowflakeParserRESPONSE_TRANSLATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6479) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6480) + p.Id_() + } + + } + { + p.SetState(6483) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6484) + p.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 +} + +// ICreate_external_tableContext is an interface to support dynamic dispatch. +type ICreate_external_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + LR_BRACKET() antlr.TerminalNode + External_table_column_decl_list() IExternal_table_column_decl_listContext + RR_BRACKET() antlr.TerminalNode + LOCATION() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + External_stage() IExternal_stageContext + File_format() IFile_formatContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + Cloud_provider_params3() ICloud_provider_params3Context + Partition_by() IPartition_byContext + WITH() antlr.TerminalNode + REFRESH_ON_CREATE() antlr.TerminalNode + AllTrue_false() []ITrue_falseContext + True_false(i int) ITrue_falseContext + AUTO_REFRESH() antlr.TerminalNode + Pattern() IPatternContext + AWS_SNS_TOPIC() antlr.TerminalNode + String_() IStringContext + Copy_grants() ICopy_grantsContext + With_row_access_policy() IWith_row_access_policyContext + With_tags() IWith_tagsContext + Comment_clause() IComment_clauseContext + PARTITION_TYPE() antlr.TerminalNode + USER_SPECIFIED() antlr.TerminalNode + TABLE_FORMAT() antlr.TerminalNode + DELTA() antlr.TerminalNode + + // IsCreate_external_tableContext differentiates from other interfaces. + IsCreate_external_tableContext() +} + +type Create_external_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_external_tableContext() *Create_external_tableContext { + var p = new(Create_external_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_external_table + return p +} + +func InitEmptyCreate_external_tableContext(p *Create_external_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_external_table +} + +func (*Create_external_tableContext) IsCreate_external_tableContext() {} + +func NewCreate_external_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_external_tableContext { + var p = new(Create_external_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_external_table + + return p +} + +func (s *Create_external_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_external_tableContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_external_tableContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Create_external_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Create_external_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_external_tableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Create_external_tableContext) External_table_column_decl_list() IExternal_table_column_decl_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_column_decl_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_column_decl_listContext) +} + +func (s *Create_external_tableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Create_external_tableContext) LOCATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCATION, 0) +} + +func (s *Create_external_tableContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_external_tableContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_external_tableContext) External_stage() IExternal_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_stageContext) +} + +func (s *Create_external_tableContext) File_format() IFile_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_formatContext) +} + +func (s *Create_external_tableContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_external_tableContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_external_tableContext) Cloud_provider_params3() ICloud_provider_params3Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICloud_provider_params3Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICloud_provider_params3Context) +} + +func (s *Create_external_tableContext) Partition_by() IPartition_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_byContext) +} + +func (s *Create_external_tableContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Create_external_tableContext) REFRESH_ON_CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH_ON_CREATE, 0) +} + +func (s *Create_external_tableContext) AllTrue_false() []ITrue_falseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrue_falseContext); ok { + len++ + } + } + + tst := make([]ITrue_falseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrue_falseContext); ok { + tst[i] = t.(ITrue_falseContext) + i++ + } + } + + return tst +} + +func (s *Create_external_tableContext) True_false(i int) ITrue_falseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_external_tableContext) AUTO_REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_REFRESH, 0) +} + +func (s *Create_external_tableContext) Pattern() IPatternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPatternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPatternContext) +} + +func (s *Create_external_tableContext) AWS_SNS_TOPIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS_TOPIC, 0) +} + +func (s *Create_external_tableContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_external_tableContext) Copy_grants() ICopy_grantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_grantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_grantsContext) +} + +func (s *Create_external_tableContext) With_row_access_policy() IWith_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_row_access_policyContext) +} + +func (s *Create_external_tableContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Create_external_tableContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_external_tableContext) PARTITION_TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARTITION_TYPE, 0) +} + +func (s *Create_external_tableContext) USER_SPECIFIED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_SPECIFIED, 0) +} + +func (s *Create_external_tableContext) TABLE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE_FORMAT, 0) +} + +func (s *Create_external_tableContext) DELTA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELTA, 0) +} + +func (s *Create_external_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_external_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_external_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_external_table(s) + } +} + +func (s *Create_external_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_external_table(s) + } +} + +func (s *Create_external_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_external_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_external_table() (localctx ICreate_external_tableContext) { + localctx = NewCreate_external_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, SnowflakeParserRULE_create_external_table) + var _la int + + p.SetState(6629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 746, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6486) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6487) + p.Or_replace() + } + + } + { + p.SetState(6490) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6491) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6493) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 715, p.GetParserRuleContext()) == 1 { + { + p.SetState(6492) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6495) + p.Object_name() + } + { + p.SetState(6496) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6497) + p.External_table_column_decl_list() + } + { + p.SetState(6498) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserINTEGRATION { + { + p.SetState(6499) + p.Cloud_provider_params3() + } + + } + p.SetState(6503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPARTITION { + { + p.SetState(6502) + p.Partition_by() + } + + } + p.SetState(6506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(6505) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6508) + p.Match(SnowflakeParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6509) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6510) + p.External_stage() + } + p.SetState(6514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREFRESH_ON_CREATE { + { + p.SetState(6511) + p.Match(SnowflakeParserREFRESH_ON_CREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6512) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6513) + p.True_false() + } + + } + p.SetState(6519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAUTO_REFRESH { + { + p.SetState(6516) + p.Match(SnowflakeParserAUTO_REFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6517) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6518) + p.True_false() + } + + } + p.SetState(6522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPATTERN { + { + p.SetState(6521) + p.Pattern() + } + + } + { + p.SetState(6524) + p.File_format() + } + p.SetState(6528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAWS_SNS_TOPIC { + { + p.SetState(6525) + p.Match(SnowflakeParserAWS_SNS_TOPIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6526) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6527) + p.String_() + } + + } + p.SetState(6531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(6530) + p.Copy_grants() + } + + } + p.SetState(6534) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 724, p.GetParserRuleContext()) == 1 { + { + p.SetState(6533) + p.With_row_access_policy() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(6536) + p.With_tags() + } + + } + p.SetState(6540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6539) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6542) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6543) + p.Or_replace() + } + + } + { + p.SetState(6546) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6547) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6549) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 728, p.GetParserRuleContext()) == 1 { + { + p.SetState(6548) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6551) + p.Object_name() + } + { + p.SetState(6552) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6553) + p.External_table_column_decl_list() + } + { + p.SetState(6554) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserINTEGRATION { + { + p.SetState(6555) + p.Cloud_provider_params3() + } + + } + p.SetState(6559) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPARTITION { + { + p.SetState(6558) + p.Partition_by() + } + + } + p.SetState(6562) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(6561) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6564) + p.Match(SnowflakeParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6565) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6566) + p.External_stage() + } + { + p.SetState(6567) + p.Match(SnowflakeParserPARTITION_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6568) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6569) + p.Match(SnowflakeParserUSER_SPECIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6570) + p.File_format() + } + p.SetState(6572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(6571) + p.Copy_grants() + } + + } + p.SetState(6575) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 733, p.GetParserRuleContext()) == 1 { + { + p.SetState(6574) + p.With_row_access_policy() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(6577) + p.With_tags() + } + + } + p.SetState(6581) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6580) + p.Comment_clause() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6583) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6584) + p.Or_replace() + } + + } + { + p.SetState(6587) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6588) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6590) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 737, p.GetParserRuleContext()) == 1 { + { + p.SetState(6589) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6592) + p.Object_name() + } + { + p.SetState(6593) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6594) + p.External_table_column_decl_list() + } + { + p.SetState(6595) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserINTEGRATION { + { + p.SetState(6596) + p.Cloud_provider_params3() + } + + } + p.SetState(6600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPARTITION { + { + p.SetState(6599) + p.Partition_by() + } + + } + p.SetState(6603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(6602) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6605) + p.Match(SnowflakeParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6606) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6607) + p.External_stage() + } + { + p.SetState(6608) + p.Match(SnowflakeParserPARTITION_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6609) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6610) + p.Match(SnowflakeParserUSER_SPECIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6611) + p.File_format() + } + p.SetState(6615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTABLE_FORMAT { + { + p.SetState(6612) + p.Match(SnowflakeParserTABLE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6613) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6614) + p.Match(SnowflakeParserDELTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(6617) + p.Copy_grants() + } + + } + p.SetState(6621) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 743, p.GetParserRuleContext()) == 1 { + { + p.SetState(6620) + p.With_row_access_policy() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(6623) + p.With_tags() + } + + } + p.SetState(6627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6626) + p.Comment_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 +} + +// IExternal_table_column_declContext is an interface to support dynamic dispatch. +type IExternal_table_column_declContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Data_type() IData_typeContext + AS() antlr.TerminalNode + Expr() IExprContext + Id_() IId_Context + Inline_constraint() IInline_constraintContext + + // IsExternal_table_column_declContext differentiates from other interfaces. + IsExternal_table_column_declContext() +} + +type External_table_column_declContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_column_declContext() *External_table_column_declContext { + var p = new(External_table_column_declContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_table_column_decl + return p +} + +func InitEmptyExternal_table_column_declContext(p *External_table_column_declContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_table_column_decl +} + +func (*External_table_column_declContext) IsExternal_table_column_declContext() {} + +func NewExternal_table_column_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_column_declContext { + var p = new(External_table_column_declContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_external_table_column_decl + + return p +} + +func (s *External_table_column_declContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_column_declContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *External_table_column_declContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *External_table_column_declContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *External_table_column_declContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *External_table_column_declContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *External_table_column_declContext) Inline_constraint() IInline_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *External_table_column_declContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_column_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_column_declContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExternal_table_column_decl(s) + } +} + +func (s *External_table_column_declContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExternal_table_column_decl(s) + } +} + +func (s *External_table_column_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExternal_table_column_decl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) External_table_column_decl() (localctx IExternal_table_column_declContext) { + localctx = NewExternal_table_column_declContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, SnowflakeParserRULE_external_table_column_decl) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6631) + p.Column_name() + } + { + p.SetState(6632) + p.Data_type() + } + { + p.SetState(6633) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 747, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6634) + p.expr(0) + } + + case 2: + { + p.SetState(6635) + p.Id_() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(6639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCONSTRAINT || _la == SnowflakeParserFOREIGN || _la == SnowflakeParserNOT || _la == SnowflakeParserNULL_ || _la == SnowflakeParserPRIMARY || _la == SnowflakeParserREFERENCES || _la == SnowflakeParserUNIQUE { + { + p.SetState(6638) + p.Inline_constraint() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_column_decl_listContext is an interface to support dynamic dispatch. +type IExternal_table_column_decl_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExternal_table_column_decl() []IExternal_table_column_declContext + External_table_column_decl(i int) IExternal_table_column_declContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExternal_table_column_decl_listContext differentiates from other interfaces. + IsExternal_table_column_decl_listContext() +} + +type External_table_column_decl_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_column_decl_listContext() *External_table_column_decl_listContext { + var p = new(External_table_column_decl_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_table_column_decl_list + return p +} + +func InitEmptyExternal_table_column_decl_listContext(p *External_table_column_decl_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_table_column_decl_list +} + +func (*External_table_column_decl_listContext) IsExternal_table_column_decl_listContext() {} + +func NewExternal_table_column_decl_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_column_decl_listContext { + var p = new(External_table_column_decl_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_external_table_column_decl_list + + return p +} + +func (s *External_table_column_decl_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_column_decl_listContext) AllExternal_table_column_decl() []IExternal_table_column_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExternal_table_column_declContext); ok { + len++ + } + } + + tst := make([]IExternal_table_column_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExternal_table_column_declContext); ok { + tst[i] = t.(IExternal_table_column_declContext) + i++ + } + } + + return tst +} + +func (s *External_table_column_decl_listContext) External_table_column_decl(i int) IExternal_table_column_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_column_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_column_declContext) +} + +func (s *External_table_column_decl_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *External_table_column_decl_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *External_table_column_decl_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_column_decl_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_column_decl_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExternal_table_column_decl_list(s) + } +} + +func (s *External_table_column_decl_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExternal_table_column_decl_list(s) + } +} + +func (s *External_table_column_decl_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExternal_table_column_decl_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) External_table_column_decl_list() (localctx IExternal_table_column_decl_listContext) { + localctx = NewExternal_table_column_decl_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, SnowflakeParserRULE_external_table_column_decl_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6641) + p.External_table_column_decl() + } + p.SetState(6646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6642) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6643) + p.External_table_column_decl() + } + + p.SetState(6648) + 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 +} + +// IFull_acctContext is an interface to support dynamic dispatch. +type IFull_acctContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsFull_acctContext differentiates from other interfaces. + IsFull_acctContext() +} + +type Full_acctContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFull_acctContext() *Full_acctContext { + var p = new(Full_acctContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_full_acct + return p +} + +func InitEmptyFull_acctContext(p *Full_acctContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_full_acct +} + +func (*Full_acctContext) IsFull_acctContext() {} + +func NewFull_acctContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_acctContext { + var p = new(Full_acctContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_full_acct + + return p +} + +func (s *Full_acctContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_acctContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Full_acctContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Full_acctContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *Full_acctContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_acctContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_acctContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFull_acct(s) + } +} + +func (s *Full_acctContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFull_acct(s) + } +} + +func (s *Full_acctContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFull_acct(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Full_acct() (localctx IFull_acctContext) { + localctx = NewFull_acctContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, SnowflakeParserRULE_full_acct) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6649) + p.Id_() + } + { + p.SetState(6650) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6651) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIntegration_type_nameContext is an interface to support dynamic dispatch. +type IIntegration_type_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SECURITY() antlr.TerminalNode + INTEGRATIONS() antlr.TerminalNode + API() antlr.TerminalNode + + // IsIntegration_type_nameContext differentiates from other interfaces. + IsIntegration_type_nameContext() +} + +type Integration_type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIntegration_type_nameContext() *Integration_type_nameContext { + var p = new(Integration_type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_integration_type_name + return p +} + +func InitEmptyIntegration_type_nameContext(p *Integration_type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_integration_type_name +} + +func (*Integration_type_nameContext) IsIntegration_type_nameContext() {} + +func NewIntegration_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Integration_type_nameContext { + var p = new(Integration_type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_integration_type_name + + return p +} + +func (s *Integration_type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Integration_type_nameContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Integration_type_nameContext) INTEGRATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATIONS, 0) +} + +func (s *Integration_type_nameContext) API() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI, 0) +} + +func (s *Integration_type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Integration_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Integration_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIntegration_type_name(s) + } +} + +func (s *Integration_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIntegration_type_name(s) + } +} + +func (s *Integration_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIntegration_type_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Integration_type_name() (localctx IIntegration_type_nameContext) { + localctx = NewIntegration_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, SnowflakeParserRULE_integration_type_name) + p.SetState(6657) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSECURITY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6653) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6654) + p.Match(SnowflakeParserINTEGRATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAPI: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6655) + p.Match(SnowflakeParserAPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6656) + p.Match(SnowflakeParserINTEGRATIONS) + 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 +} + +// ICreate_failover_groupContext is an interface to support dynamic dispatch. +type ICreate_failover_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + OBJECT_TYPES() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllObject_type() []IObject_typeContext + Object_type(i int) IObject_typeContext + ALLOWED_ACCOUNTS() antlr.TerminalNode + AllFull_acct() []IFull_acctContext + Full_acct(i int) IFull_acctContext + If_not_exists() IIf_not_existsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALLOWED_DATABASES() antlr.TerminalNode + ALLOWED_SHARES() antlr.TerminalNode + ALLOWED_INTEGRATION_TYPES() antlr.TerminalNode + AllIntegration_type_name() []IIntegration_type_nameContext + Integration_type_name(i int) IIntegration_type_nameContext + IGNORE() antlr.TerminalNode + EDITION() antlr.TerminalNode + CHECK() antlr.TerminalNode + REPLICATION_SCHEDULE() antlr.TerminalNode + String_() IStringContext + AS() antlr.TerminalNode + REPLICA() antlr.TerminalNode + OF() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsCreate_failover_groupContext differentiates from other interfaces. + IsCreate_failover_groupContext() +} + +type Create_failover_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_failover_groupContext() *Create_failover_groupContext { + var p = new(Create_failover_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_failover_group + return p +} + +func InitEmptyCreate_failover_groupContext(p *Create_failover_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_failover_group +} + +func (*Create_failover_groupContext) IsCreate_failover_groupContext() {} + +func NewCreate_failover_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_failover_groupContext { + var p = new(Create_failover_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_failover_group + + return p +} + +func (s *Create_failover_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_failover_groupContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_failover_groupContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, 0) +} + +func (s *Create_failover_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Create_failover_groupContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_failover_groupContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_failover_groupContext) OBJECT_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT_TYPES, 0) +} + +func (s *Create_failover_groupContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_failover_groupContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_failover_groupContext) AllObject_type() []IObject_typeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_typeContext); ok { + len++ + } + } + + tst := make([]IObject_typeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_typeContext); ok { + tst[i] = t.(IObject_typeContext) + i++ + } + } + + return tst +} + +func (s *Create_failover_groupContext) Object_type(i int) IObject_typeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_typeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_typeContext) +} + +func (s *Create_failover_groupContext) ALLOWED_ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_ACCOUNTS, 0) +} + +func (s *Create_failover_groupContext) AllFull_acct() []IFull_acctContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFull_acctContext); ok { + len++ + } + } + + tst := make([]IFull_acctContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFull_acctContext); ok { + tst[i] = t.(IFull_acctContext) + i++ + } + } + + return tst +} + +func (s *Create_failover_groupContext) Full_acct(i int) IFull_acctContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_acctContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFull_acctContext) +} + +func (s *Create_failover_groupContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_failover_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_failover_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_failover_groupContext) ALLOWED_DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_DATABASES, 0) +} + +func (s *Create_failover_groupContext) ALLOWED_SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_SHARES, 0) +} + +func (s *Create_failover_groupContext) ALLOWED_INTEGRATION_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_INTEGRATION_TYPES, 0) +} + +func (s *Create_failover_groupContext) AllIntegration_type_name() []IIntegration_type_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIntegration_type_nameContext); ok { + len++ + } + } + + tst := make([]IIntegration_type_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIntegration_type_nameContext); ok { + tst[i] = t.(IIntegration_type_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_failover_groupContext) Integration_type_name(i int) IIntegration_type_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntegration_type_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIntegration_type_nameContext) +} + +func (s *Create_failover_groupContext) IGNORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE, 0) +} + +func (s *Create_failover_groupContext) EDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEDITION, 0) +} + +func (s *Create_failover_groupContext) CHECK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHECK, 0) +} + +func (s *Create_failover_groupContext) REPLICATION_SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION_SCHEDULE, 0) +} + +func (s *Create_failover_groupContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_failover_groupContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_failover_groupContext) REPLICA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICA, 0) +} + +func (s *Create_failover_groupContext) OF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOF, 0) +} + +func (s *Create_failover_groupContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserDOT) +} + +func (s *Create_failover_groupContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, i) +} + +func (s *Create_failover_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_failover_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_failover_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_failover_group(s) + } +} + +func (s *Create_failover_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_failover_group(s) + } +} + +func (s *Create_failover_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_failover_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_failover_group() (localctx ICreate_failover_groupContext) { + localctx = NewCreate_failover_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, SnowflakeParserRULE_create_failover_group) + var _la int + + p.SetState(6748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 763, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6659) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6660) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6661) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6663) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 751, p.GetParserRuleContext()) == 1 { + { + p.SetState(6662) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6665) + p.Id_() + } + { + p.SetState(6666) + p.Match(SnowflakeParserOBJECT_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6667) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6668) + p.Object_type() + } + p.SetState(6673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6669) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6670) + p.Object_type() + } + + p.SetState(6675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOWED_DATABASES { + { + p.SetState(6676) + p.Match(SnowflakeParserALLOWED_DATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6677) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6678) + p.Id_() + } + p.SetState(6683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6679) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6680) + p.Id_() + } + + p.SetState(6685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(6698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOWED_SHARES { + { + p.SetState(6688) + p.Match(SnowflakeParserALLOWED_SHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6689) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6690) + p.Id_() + } + p.SetState(6695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6691) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6692) + p.Id_() + } + + p.SetState(6697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(6710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOWED_INTEGRATION_TYPES { + { + p.SetState(6700) + p.Match(SnowflakeParserALLOWED_INTEGRATION_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6701) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6702) + p.Integration_type_name() + } + p.SetState(6707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6703) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6704) + p.Integration_type_name() + } + + p.SetState(6709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(6712) + p.Match(SnowflakeParserALLOWED_ACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6713) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6714) + p.Full_acct() + } + p.SetState(6719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6715) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6716) + p.Full_acct() + } + + p.SetState(6721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIGNORE { + { + p.SetState(6722) + p.Match(SnowflakeParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6723) + p.Match(SnowflakeParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6724) + p.Match(SnowflakeParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6730) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREPLICATION_SCHEDULE { + { + p.SetState(6727) + p.Match(SnowflakeParserREPLICATION_SCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6728) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6729) + p.String_() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6732) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6733) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6734) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6736) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 762, p.GetParserRuleContext()) == 1 { + { + p.SetState(6735) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6738) + p.Id_() + } + { + p.SetState(6739) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6740) + p.Match(SnowflakeParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6741) + p.Match(SnowflakeParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6742) + p.Id_() + } + { + p.SetState(6743) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6744) + p.Id_() + } + { + p.SetState(6745) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6746) + p.Id_() + } + + 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_fileformatContext is an interface to support dynamic dispatch. +type IType_fileformatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CSV() antlr.TerminalNode + JSON() antlr.TerminalNode + AVRO() antlr.TerminalNode + ORC() antlr.TerminalNode + PARQUET() antlr.TerminalNode + XML() antlr.TerminalNode + CSV_Q() antlr.TerminalNode + JSON_Q() antlr.TerminalNode + AVRO_Q() antlr.TerminalNode + ORC_Q() antlr.TerminalNode + PARQUET_Q() antlr.TerminalNode + XML_Q() antlr.TerminalNode + + // IsType_fileformatContext differentiates from other interfaces. + IsType_fileformatContext() +} + +type Type_fileformatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_fileformatContext() *Type_fileformatContext { + var p = new(Type_fileformatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_type_fileformat + return p +} + +func InitEmptyType_fileformatContext(p *Type_fileformatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_type_fileformat +} + +func (*Type_fileformatContext) IsType_fileformatContext() {} + +func NewType_fileformatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_fileformatContext { + var p = new(Type_fileformatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_type_fileformat + + return p +} + +func (s *Type_fileformatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_fileformatContext) CSV() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCSV, 0) +} + +func (s *Type_fileformatContext) JSON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON, 0) +} + +func (s *Type_fileformatContext) AVRO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVRO, 0) +} + +func (s *Type_fileformatContext) ORC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORC, 0) +} + +func (s *Type_fileformatContext) PARQUET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARQUET, 0) +} + +func (s *Type_fileformatContext) XML() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXML, 0) +} + +func (s *Type_fileformatContext) CSV_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCSV_Q, 0) +} + +func (s *Type_fileformatContext) JSON_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON_Q, 0) +} + +func (s *Type_fileformatContext) AVRO_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVRO_Q, 0) +} + +func (s *Type_fileformatContext) ORC_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORC_Q, 0) +} + +func (s *Type_fileformatContext) PARQUET_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARQUET_Q, 0) +} + +func (s *Type_fileformatContext) XML_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXML_Q, 0) +} + +func (s *Type_fileformatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_fileformatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_fileformatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterType_fileformat(s) + } +} + +func (s *Type_fileformatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitType_fileformat(s) + } +} + +func (s *Type_fileformatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitType_fileformat(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Type_fileformat() (localctx IType_fileformatContext) { + localctx = NewType_fileformatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, SnowflakeParserRULE_type_fileformat) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6750) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAVRO || _la == SnowflakeParserAVRO_Q || _la == SnowflakeParserCSV || _la == SnowflakeParserCSV_Q || _la == SnowflakeParserJSON || _la == SnowflakeParserJSON_Q || ((int64((_la-565)) & ^0x3f) == 0 && ((int64(1)<<(_la-565))&196611) != 0) || _la == SnowflakeParserXML || _la == SnowflakeParserXML_Q) { + 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 +} + +// ICreate_file_formatContext is an interface to support dynamic dispatch. +type ICreate_file_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + Object_name() IObject_nameContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + TYPE() antlr.TerminalNode + EQ() antlr.TerminalNode + Type_fileformat() IType_fileformatContext + AllFormat_type_options() []IFormat_type_optionsContext + Format_type_options(i int) IFormat_type_optionsContext + Comment_clause() IComment_clauseContext + + // IsCreate_file_formatContext differentiates from other interfaces. + IsCreate_file_formatContext() +} + +type Create_file_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_file_formatContext() *Create_file_formatContext { + var p = new(Create_file_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_file_format + return p +} + +func InitEmptyCreate_file_formatContext(p *Create_file_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_file_format +} + +func (*Create_file_formatContext) IsCreate_file_formatContext() {} + +func NewCreate_file_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_file_formatContext { + var p = new(Create_file_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_file_format + + return p +} + +func (s *Create_file_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_file_formatContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_file_formatContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Create_file_formatContext) FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT, 0) +} + +func (s *Create_file_formatContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_file_formatContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_file_formatContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_file_formatContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_file_formatContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Create_file_formatContext) Type_fileformat() IType_fileformatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_fileformatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_fileformatContext) +} + +func (s *Create_file_formatContext) AllFormat_type_options() []IFormat_type_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + len++ + } + } + + tst := make([]IFormat_type_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFormat_type_optionsContext); ok { + tst[i] = t.(IFormat_type_optionsContext) + i++ + } + } + + return tst +} + +func (s *Create_file_formatContext) Format_type_options(i int) IFormat_type_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFormat_type_optionsContext) +} + +func (s *Create_file_formatContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_file_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_file_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_file_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_file_format(s) + } +} + +func (s *Create_file_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_file_format(s) + } +} + +func (s *Create_file_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_file_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_file_format() (localctx ICreate_file_formatContext) { + localctx = NewCreate_file_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, SnowflakeParserRULE_create_file_format) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6752) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6753) + p.Or_replace() + } + + } + { + p.SetState(6756) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6757) + p.Match(SnowflakeParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6759) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 765, p.GetParserRuleContext()) == 1 { + { + p.SetState(6758) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6761) + p.Object_name() + } + p.SetState(6765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(6762) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6763) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6764) + p.Type_fileformat() + } + + } + p.SetState(6770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserALLOW_DUPLICATE || ((int64((_la-97)) & ^0x3f) == 0 && ((int64(1)<<(_la-97))&18437) != 0) || _la == SnowflakeParserCOMPRESSION || _la == SnowflakeParserDATE_FORMAT || ((int64((_la-230)) & ^0x3f) == 0 && ((int64(1)<<(_la-230))&879628696688641) != 0) || ((int64((_la-312)) & ^0x3f) == 0 && ((int64(1)<<(_la-312))&1152925902653358099) != 0) || _la == SnowflakeParserLZO || _la == SnowflakeParserNONE || _la == SnowflakeParserNULL_IF || ((int64((_la-615)) & ^0x3f) == 0 && ((int64(1)<<(_la-615))&1125917086711809) != 0) || _la == SnowflakeParserREPLACE_INVALID_CHARACTERS || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&8070450532247929043) != 0) || ((int64((_la-906)) & ^0x3f) == 0 && ((int64(1)<<(_la-906))&34359746561) != 0) || _la == SnowflakeParserZSTD { + { + p.SetState(6767) + p.Format_type_options() + } + + p.SetState(6772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6773) + p.Comment_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 +} + +// IArg_declContext is an interface to support dynamic dispatch. +type IArg_declContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Arg_name() IArg_nameContext + Arg_data_type() IArg_data_typeContext + + // IsArg_declContext differentiates from other interfaces. + IsArg_declContext() +} + +type Arg_declContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArg_declContext() *Arg_declContext { + var p = new(Arg_declContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arg_decl + return p +} + +func InitEmptyArg_declContext(p *Arg_declContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arg_decl +} + +func (*Arg_declContext) IsArg_declContext() {} + +func NewArg_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arg_declContext { + var p = new(Arg_declContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_arg_decl + + return p +} + +func (s *Arg_declContext) GetParser() antlr.Parser { return s.parser } + +func (s *Arg_declContext) Arg_name() IArg_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArg_nameContext) +} + +func (s *Arg_declContext) Arg_data_type() IArg_data_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_data_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArg_data_typeContext) +} + +func (s *Arg_declContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Arg_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Arg_declContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterArg_decl(s) + } +} + +func (s *Arg_declContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitArg_decl(s) + } +} + +func (s *Arg_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitArg_decl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Arg_decl() (localctx IArg_declContext) { + localctx = NewArg_declContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, SnowflakeParserRULE_arg_decl) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6776) + p.Arg_name() + } + { + p.SetState(6777) + p.Arg_data_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 +} + +// ICol_declContext is an interface to support dynamic dispatch. +type ICol_declContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Data_type() IData_typeContext + + // IsCol_declContext differentiates from other interfaces. + IsCol_declContext() +} + +type Col_declContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCol_declContext() *Col_declContext { + var p = new(Col_declContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_col_decl + return p +} + +func InitEmptyCol_declContext(p *Col_declContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_col_decl +} + +func (*Col_declContext) IsCol_declContext() {} + +func NewCol_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Col_declContext { + var p = new(Col_declContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_col_decl + + return p +} + +func (s *Col_declContext) GetParser() antlr.Parser { return s.parser } + +func (s *Col_declContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Col_declContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Col_declContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Col_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Col_declContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCol_decl(s) + } +} + +func (s *Col_declContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCol_decl(s) + } +} + +func (s *Col_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCol_decl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Col_decl() (localctx ICol_declContext) { + localctx = NewCol_declContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, SnowflakeParserRULE_col_decl) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6779) + p.Column_name() + } + { + p.SetState(6780) + p.Data_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 +} + +// IFunction_definitionContext is an interface to support dynamic dispatch. +type IFunction_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + String_() IStringContext + DBL_DOLLAR() antlr.TerminalNode + + // IsFunction_definitionContext differentiates from other interfaces. + IsFunction_definitionContext() +} + +type Function_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_definitionContext() *Function_definitionContext { + var p = new(Function_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_function_definition + return p +} + +func InitEmptyFunction_definitionContext(p *Function_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_function_definition +} + +func (*Function_definitionContext) IsFunction_definitionContext() {} + +func NewFunction_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_definitionContext { + var p = new(Function_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_function_definition + + return p +} + +func (s *Function_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_definitionContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Function_definitionContext) DBL_DOLLAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDBL_DOLLAR, 0) +} + +func (s *Function_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFunction_definition(s) + } +} + +func (s *Function_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFunction_definition(s) + } +} + +func (s *Function_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFunction_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Function_definition() (localctx IFunction_definitionContext) { + localctx = NewFunction_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, SnowflakeParserRULE_function_definition) + p.SetState(6784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6782) + p.String_() + } + + case SnowflakeParserDBL_DOLLAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6783) + p.Match(SnowflakeParserDBL_DOLLAR) + 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 +} + +// ICreate_functionContext is an interface to support dynamic dispatch. +type ICreate_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Object_name() IObject_nameContext + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllRETURNS() []antlr.TerminalNode + RETURNS(i int) antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + JAVASCRIPT() antlr.TerminalNode + AS() antlr.TerminalNode + Function_definition() IFunction_definitionContext + Data_type() IData_typeContext + TABLE() antlr.TerminalNode + Or_replace() IOr_replaceContext + SECURE() antlr.TerminalNode + AllArg_decl() []IArg_declContext + Arg_decl(i int) IArg_declContext + Null_not_null() INull_not_nullContext + CALLED() antlr.TerminalNode + ON() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + INPUT() antlr.TerminalNode + STRICT() antlr.TerminalNode + Comment_clause() IComment_clauseContext + VOLATILE() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + AllCol_decl() []ICol_declContext + Col_decl(i int) ICol_declContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + MEMOIZABLE() antlr.TerminalNode + + // IsCreate_functionContext differentiates from other interfaces. + IsCreate_functionContext() +} + +type Create_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_functionContext() *Create_functionContext { + var p = new(Create_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_function + return p +} + +func InitEmptyCreate_functionContext(p *Create_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_function +} + +func (*Create_functionContext) IsCreate_functionContext() {} + +func NewCreate_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_functionContext { + var p = new(Create_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_function + + return p +} + +func (s *Create_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_functionContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Create_functionContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_functionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_functionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_functionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_functionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_functionContext) AllRETURNS() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRETURNS) +} + +func (s *Create_functionContext) RETURNS(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURNS, i) +} + +func (s *Create_functionContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLANGUAGE, 0) +} + +func (s *Create_functionContext) JAVASCRIPT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJAVASCRIPT, 0) +} + +func (s *Create_functionContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_functionContext) Function_definition() IFunction_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_definitionContext) +} + +func (s *Create_functionContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Create_functionContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Create_functionContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_functionContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Create_functionContext) AllArg_decl() []IArg_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArg_declContext); ok { + len++ + } + } + + tst := make([]IArg_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArg_declContext); ok { + tst[i] = t.(IArg_declContext) + i++ + } + } + + return tst +} + +func (s *Create_functionContext) Arg_decl(i int) IArg_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArg_declContext) +} + +func (s *Create_functionContext) Null_not_null() INull_not_nullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_not_nullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_not_nullContext) +} + +func (s *Create_functionContext) CALLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCALLED, 0) +} + +func (s *Create_functionContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Create_functionContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserNULL_) +} + +func (s *Create_functionContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, i) +} + +func (s *Create_functionContext) INPUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINPUT, 0) +} + +func (s *Create_functionContext) STRICT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRICT, 0) +} + +func (s *Create_functionContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_functionContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVOLATILE, 0) +} + +func (s *Create_functionContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMUTABLE, 0) +} + +func (s *Create_functionContext) AllCol_decl() []ICol_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICol_declContext); ok { + len++ + } + } + + tst := make([]ICol_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICol_declContext); ok { + tst[i] = t.(ICol_declContext) + i++ + } + } + + return tst +} + +func (s *Create_functionContext) Col_decl(i int) ICol_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICol_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICol_declContext) +} + +func (s *Create_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_functionContext) MEMOIZABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMEMOIZABLE, 0) +} + +func (s *Create_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_function(s) + } +} + +func (s *Create_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_function(s) + } +} + +func (s *Create_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_function() (localctx ICreate_functionContext) { + localctx = NewCreate_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, SnowflakeParserRULE_create_function) + var _la int + + p.SetState(6915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 793, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6786) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6787) + p.Or_replace() + } + + } + p.SetState(6791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURE { + { + p.SetState(6790) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6793) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6794) + p.Object_name() + } + { + p.SetState(6795) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(6796) + p.Arg_decl() + } + p.SetState(6801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6797) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6798) + p.Arg_decl() + } + + p.SetState(6803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(6806) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6807) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserDOUBLE, SnowflakeParserINT, SnowflakeParserNUMBER, SnowflakeParserOBJECT, SnowflakeParserTIME, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserARRAY, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNUMERIC, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT: + { + p.SetState(6808) + p.Data_type() + } + + case SnowflakeParserTABLE: + { + p.SetState(6809) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6810) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(6811) + p.Col_decl() + } + p.SetState(6816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6812) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6813) + p.Col_decl() + } + + p.SetState(6818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(6821) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT || _la == SnowflakeParserNULL_ { + { + p.SetState(6824) + p.Null_not_null() + } + + } + { + p.SetState(6827) + p.Match(SnowflakeParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6828) + p.Match(SnowflakeParserJAVASCRIPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCALLED: + { + p.SetState(6829) + p.Match(SnowflakeParserCALLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6830) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6831) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6832) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRETURNS: + { + p.SetState(6833) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6834) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6835) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6836) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6837) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTRICT: + { + p.SetState(6838) + p.Match(SnowflakeParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAS, SnowflakeParserCOMMENT, SnowflakeParserIMMUTABLE, SnowflakeParserVOLATILE: + + default: + } + p.SetState(6842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE { + { + p.SetState(6841) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6844) + p.Comment_clause() + } + + } + { + p.SetState(6847) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6848) + p.Function_definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6850) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6851) + p.Or_replace() + } + + } + p.SetState(6855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURE { + { + p.SetState(6854) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6857) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6858) + p.Object_name() + } + { + p.SetState(6859) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(6860) + p.Arg_decl() + } + p.SetState(6865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6861) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6862) + p.Arg_decl() + } + + p.SetState(6867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(6870) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6871) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserDOUBLE, SnowflakeParserINT, SnowflakeParserNUMBER, SnowflakeParserOBJECT, SnowflakeParserTIME, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserARRAY, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNUMERIC, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT: + { + p.SetState(6872) + p.Data_type() + } + + case SnowflakeParserTABLE: + { + p.SetState(6873) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6874) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(6875) + p.Col_decl() + } + p.SetState(6880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(6876) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6877) + p.Col_decl() + } + + p.SetState(6882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(6885) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6889) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT || _la == SnowflakeParserNULL_ { + { + p.SetState(6888) + p.Null_not_null() + } + + } + p.SetState(6901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCALLED: + { + p.SetState(6891) + p.Match(SnowflakeParserCALLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6892) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6893) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6894) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRETURNS: + { + p.SetState(6895) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6896) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6897) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6898) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6899) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTRICT: + { + p.SetState(6900) + p.Match(SnowflakeParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAS, SnowflakeParserCOMMENT, SnowflakeParserIMMUTABLE, SnowflakeParserMEMOIZABLE, SnowflakeParserVOLATILE: + + default: + } + p.SetState(6904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE { + { + p.SetState(6903) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMEMOIZABLE { + { + p.SetState(6906) + p.Match(SnowflakeParserMEMOIZABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6909) + p.Comment_clause() + } + + } + { + p.SetState(6912) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6913) + p.Function_definition() + } + + 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_managed_accountContext is an interface to support dynamic dispatch. +type ICreate_managed_accountContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + MANAGED() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + ADMIN_NAME() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ADMIN_PASSWORD() antlr.TerminalNode + String_() IStringContext + TYPE() antlr.TerminalNode + READER() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsCreate_managed_accountContext differentiates from other interfaces. + IsCreate_managed_accountContext() +} + +type Create_managed_accountContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_managed_accountContext() *Create_managed_accountContext { + var p = new(Create_managed_accountContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_managed_account + return p +} + +func InitEmptyCreate_managed_accountContext(p *Create_managed_accountContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_managed_account +} + +func (*Create_managed_accountContext) IsCreate_managed_accountContext() {} + +func NewCreate_managed_accountContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_managed_accountContext { + var p = new(Create_managed_accountContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_managed_account + + return p +} + +func (s *Create_managed_accountContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_managed_accountContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_managed_accountContext) MANAGED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMANAGED, 0) +} + +func (s *Create_managed_accountContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Create_managed_accountContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_managed_accountContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_managed_accountContext) ADMIN_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADMIN_NAME, 0) +} + +func (s *Create_managed_accountContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_managed_accountContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_managed_accountContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_managed_accountContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_managed_accountContext) ADMIN_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADMIN_PASSWORD, 0) +} + +func (s *Create_managed_accountContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_managed_accountContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_managed_accountContext) READER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREADER, 0) +} + +func (s *Create_managed_accountContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_managed_accountContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_managed_accountContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_managed_accountContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_managed_account(s) + } +} + +func (s *Create_managed_accountContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_managed_account(s) + } +} + +func (s *Create_managed_accountContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_managed_account(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_managed_account() (localctx ICreate_managed_accountContext) { + localctx = NewCreate_managed_accountContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, SnowflakeParserRULE_create_managed_account) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6917) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6918) + p.Match(SnowflakeParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6919) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6920) + p.Id_() + } + { + p.SetState(6921) + p.Match(SnowflakeParserADMIN_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6922) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6923) + p.Id_() + } + { + p.SetState(6924) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6925) + p.Match(SnowflakeParserADMIN_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6926) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6927) + p.String_() + } + { + p.SetState(6928) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6929) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6930) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6931) + p.Match(SnowflakeParserREADER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMA { + { + p.SetState(6932) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6933) + p.Comment_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 +} + +// ICreate_masking_policyContext is an interface to support dynamic dispatch. +type ICreate_masking_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Object_name() IObject_nameContext + AS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllArg_name() []IArg_nameContext + Arg_name(i int) IArg_nameContext + AllArg_data_type() []IArg_data_typeContext + Arg_data_type(i int) IArg_data_typeContext + RR_BRACKET() antlr.TerminalNode + RETURNS() antlr.TerminalNode + ARROW() antlr.TerminalNode + Expr() IExprContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + COMMA() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsCreate_masking_policyContext differentiates from other interfaces. + IsCreate_masking_policyContext() +} + +type Create_masking_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_masking_policyContext() *Create_masking_policyContext { + var p = new(Create_masking_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_masking_policy + return p +} + +func InitEmptyCreate_masking_policyContext(p *Create_masking_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_masking_policy +} + +func (*Create_masking_policyContext) IsCreate_masking_policyContext() {} + +func NewCreate_masking_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_masking_policyContext { + var p = new(Create_masking_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_masking_policy + + return p +} + +func (s *Create_masking_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_masking_policyContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_masking_policyContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Create_masking_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Create_masking_policyContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_masking_policyContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_masking_policyContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Create_masking_policyContext) AllArg_name() []IArg_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArg_nameContext); ok { + len++ + } + } + + tst := make([]IArg_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArg_nameContext); ok { + tst[i] = t.(IArg_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_masking_policyContext) Arg_name(i int) IArg_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArg_nameContext) +} + +func (s *Create_masking_policyContext) AllArg_data_type() []IArg_data_typeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArg_data_typeContext); ok { + len++ + } + } + + tst := make([]IArg_data_typeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArg_data_typeContext); ok { + tst[i] = t.(IArg_data_typeContext) + i++ + } + } + + return tst +} + +func (s *Create_masking_policyContext) Arg_data_type(i int) IArg_data_typeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_data_typeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArg_data_typeContext) +} + +func (s *Create_masking_policyContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Create_masking_policyContext) RETURNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURNS, 0) +} + +func (s *Create_masking_policyContext) ARROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARROW, 0) +} + +func (s *Create_masking_policyContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Create_masking_policyContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_masking_policyContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_masking_policyContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Create_masking_policyContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_masking_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_masking_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_masking_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_masking_policy(s) + } +} + +func (s *Create_masking_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_masking_policy(s) + } +} + +func (s *Create_masking_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_masking_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_masking_policy() (localctx ICreate_masking_policyContext) { + localctx = NewCreate_masking_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, SnowflakeParserRULE_create_masking_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6936) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6937) + p.Or_replace() + } + + } + { + p.SetState(6940) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6941) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6943) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 796, p.GetParserRuleContext()) == 1 { + { + p.SetState(6942) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6945) + p.Object_name() + } + { + p.SetState(6946) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6947) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6948) + p.Arg_name() + } + { + p.SetState(6949) + p.Arg_data_type() + } + p.SetState(6954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMA { + { + p.SetState(6950) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6951) + p.Arg_name() + } + { + p.SetState(6952) + p.Arg_data_type() + } + + } + { + p.SetState(6956) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6957) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6958) + p.Arg_data_type() + } + { + p.SetState(6959) + p.Match(SnowflakeParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6960) + p.expr(0) + } + p.SetState(6962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6961) + p.Comment_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 +} + +// ITag_declContext is an interface to support dynamic dispatch. +type ITag_declContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Object_name() IObject_nameContext + EQ() antlr.TerminalNode + String_() IStringContext + + // IsTag_declContext differentiates from other interfaces. + IsTag_declContext() +} + +type Tag_declContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTag_declContext() *Tag_declContext { + var p = new(Tag_declContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_tag_decl + return p +} + +func InitEmptyTag_declContext(p *Tag_declContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_tag_decl +} + +func (*Tag_declContext) IsTag_declContext() {} + +func NewTag_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tag_declContext { + var p = new(Tag_declContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_tag_decl + + return p +} + +func (s *Tag_declContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tag_declContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Tag_declContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Tag_declContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Tag_declContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tag_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tag_declContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTag_decl(s) + } +} + +func (s *Tag_declContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTag_decl(s) + } +} + +func (s *Tag_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTag_decl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Tag_decl() (localctx ITag_declContext) { + localctx = NewTag_declContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, SnowflakeParserRULE_tag_decl) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6964) + p.Object_name() + } + { + p.SetState(6965) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6966) + p.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 +} + +// IColumn_list_in_parenthesesContext is an interface to support dynamic dispatch. +type IColumn_list_in_parenthesesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Column_list() IColumn_listContext + RR_BRACKET() antlr.TerminalNode + + // IsColumn_list_in_parenthesesContext differentiates from other interfaces. + IsColumn_list_in_parenthesesContext() +} + +type Column_list_in_parenthesesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_list_in_parenthesesContext() *Column_list_in_parenthesesContext { + var p = new(Column_list_in_parenthesesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_list_in_parentheses + return p +} + +func InitEmptyColumn_list_in_parenthesesContext(p *Column_list_in_parenthesesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_list_in_parentheses +} + +func (*Column_list_in_parenthesesContext) IsColumn_list_in_parenthesesContext() {} + +func NewColumn_list_in_parenthesesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_list_in_parenthesesContext { + var p = new(Column_list_in_parenthesesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_list_in_parentheses + + return p +} + +func (s *Column_list_in_parenthesesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_list_in_parenthesesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Column_list_in_parenthesesContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Column_list_in_parenthesesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Column_list_in_parenthesesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_list_in_parenthesesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_list_in_parenthesesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_list_in_parentheses(s) + } +} + +func (s *Column_list_in_parenthesesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_list_in_parentheses(s) + } +} + +func (s *Column_list_in_parenthesesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_list_in_parentheses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_list_in_parentheses() (localctx IColumn_list_in_parenthesesContext) { + localctx = NewColumn_list_in_parenthesesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, SnowflakeParserRULE_column_list_in_parentheses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6968) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6969) + p.Column_list() + } + { + p.SetState(6970) + p.Match(SnowflakeParserRR_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 +} + +// ICreate_materialized_viewContext is an interface to support dynamic dispatch. +type ICreate_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Object_name() IObject_nameContext + AS() antlr.TerminalNode + Select_statement() ISelect_statementContext + Or_replace() IOr_replaceContext + SECURE() antlr.TerminalNode + If_not_exists() IIf_not_existsContext + Copy_grants() ICopy_grantsContext + Column_list_in_parentheses() IColumn_list_in_parenthesesContext + With_row_access_policy() IWith_row_access_policyContext + With_tags() IWith_tagsContext + Comment_clause() IComment_clauseContext + Cluster_by() ICluster_byContext + + // IsCreate_materialized_viewContext differentiates from other interfaces. + IsCreate_materialized_viewContext() +} + +type Create_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_materialized_viewContext() *Create_materialized_viewContext { + var p = new(Create_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_materialized_view + return p +} + +func InitEmptyCreate_materialized_viewContext(p *Create_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_materialized_view +} + +func (*Create_materialized_viewContext) IsCreate_materialized_viewContext() {} + +func NewCreate_materialized_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_materialized_viewContext { + var p = new(Create_materialized_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_materialized_view + + return p +} + +func (s *Create_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_materialized_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATERIALIZED, 0) +} + +func (s *Create_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Create_materialized_viewContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_materialized_viewContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_materialized_viewContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Create_materialized_viewContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_materialized_viewContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Create_materialized_viewContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_materialized_viewContext) Copy_grants() ICopy_grantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_grantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_grantsContext) +} + +func (s *Create_materialized_viewContext) Column_list_in_parentheses() IColumn_list_in_parenthesesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_list_in_parenthesesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_list_in_parenthesesContext) +} + +func (s *Create_materialized_viewContext) With_row_access_policy() IWith_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_row_access_policyContext) +} + +func (s *Create_materialized_viewContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Create_materialized_viewContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_materialized_viewContext) Cluster_by() ICluster_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_byContext) +} + +func (s *Create_materialized_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_materialized_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_materialized_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_materialized_view(s) + } +} + +func (s *Create_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_materialized_view(s) + } +} + +func (s *Create_materialized_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_materialized_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_materialized_view() (localctx ICreate_materialized_viewContext) { + localctx = NewCreate_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, SnowflakeParserRULE_create_materialized_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6972) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(6973) + p.Or_replace() + } + + } + p.SetState(6977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURE { + { + p.SetState(6976) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6979) + p.Match(SnowflakeParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6980) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6982) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 801, p.GetParserRuleContext()) == 1 { + { + p.SetState(6981) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6984) + p.Object_name() + } + p.SetState(6986) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(6985) + p.Copy_grants() + } + + } + p.SetState(6989) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(6988) + p.Column_list_in_parentheses() + } + + } + p.SetState(6992) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 804, p.GetParserRuleContext()) == 1 { + { + p.SetState(6991) + p.With_row_access_policy() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(6994) + p.With_tags() + } + + } + p.SetState(6998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(6997) + p.Comment_clause() + } + + } + p.SetState(7001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCLUSTER { + { + p.SetState(7000) + p.Cluster_by() + } + + } + { + p.SetState(7003) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7004) + p.Select_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_network_policyContext is an interface to support dynamic dispatch. +type ICreate_network_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + NETWORK() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + ALLOWED_IP_LIST() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Or_replace() IOr_replaceContext + AllString_list() []IString_listContext + String_list(i int) IString_listContext + BLOCKED_IP_LIST() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsCreate_network_policyContext differentiates from other interfaces. + IsCreate_network_policyContext() +} + +type Create_network_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_network_policyContext() *Create_network_policyContext { + var p = new(Create_network_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_network_policy + return p +} + +func InitEmptyCreate_network_policyContext(p *Create_network_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_network_policy +} + +func (*Create_network_policyContext) IsCreate_network_policyContext() {} + +func NewCreate_network_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_network_policyContext { + var p = new(Create_network_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_network_policy + + return p +} + +func (s *Create_network_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_network_policyContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_network_policyContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Create_network_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Create_network_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_network_policyContext) ALLOWED_IP_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_IP_LIST, 0) +} + +func (s *Create_network_policyContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_network_policyContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_network_policyContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_network_policyContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_network_policyContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_network_policyContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_network_policyContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_network_policyContext) AllString_list() []IString_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_listContext); ok { + len++ + } + } + + tst := make([]IString_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_listContext); ok { + tst[i] = t.(IString_listContext) + i++ + } + } + + return tst +} + +func (s *Create_network_policyContext) String_list(i int) IString_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Create_network_policyContext) BLOCKED_IP_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBLOCKED_IP_LIST, 0) +} + +func (s *Create_network_policyContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_network_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_network_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_network_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_network_policy(s) + } +} + +func (s *Create_network_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_network_policy(s) + } +} + +func (s *Create_network_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_network_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_network_policy() (localctx ICreate_network_policyContext) { + localctx = NewCreate_network_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, SnowflakeParserRULE_create_network_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7006) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7007) + p.Or_replace() + } + + } + { + p.SetState(7010) + p.Match(SnowflakeParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7011) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7012) + p.Id_() + } + { + p.SetState(7013) + p.Match(SnowflakeParserALLOWED_IP_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7014) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7015) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTRING { + { + p.SetState(7016) + p.String_list() + } + + } + { + p.SetState(7019) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserBLOCKED_IP_LIST { + { + p.SetState(7020) + p.Match(SnowflakeParserBLOCKED_IP_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7021) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7022) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTRING { + { + p.SetState(7023) + p.String_list() + } + + } + { + p.SetState(7026) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7029) + p.Comment_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 +} + +// ICloud_provider_params_autoContext is an interface to support dynamic dispatch. +type ICloud_provider_params_autoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOTIFICATION_PROVIDER() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + GCP_PUBSUB() antlr.TerminalNode + GCP_PUBSUB_SUBSCRIPTION_NAME() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + AZURE_EVENT_GRID() antlr.TerminalNode + AZURE_STORAGE_QUEUE_PRIMARY_URI() antlr.TerminalNode + AZURE_TENANT_ID() antlr.TerminalNode + + // IsCloud_provider_params_autoContext differentiates from other interfaces. + IsCloud_provider_params_autoContext() +} + +type Cloud_provider_params_autoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCloud_provider_params_autoContext() *Cloud_provider_params_autoContext { + var p = new(Cloud_provider_params_autoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params_auto + return p +} + +func InitEmptyCloud_provider_params_autoContext(p *Cloud_provider_params_autoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params_auto +} + +func (*Cloud_provider_params_autoContext) IsCloud_provider_params_autoContext() {} + +func NewCloud_provider_params_autoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cloud_provider_params_autoContext { + var p = new(Cloud_provider_params_autoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params_auto + + return p +} + +func (s *Cloud_provider_params_autoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cloud_provider_params_autoContext) NOTIFICATION_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION_PROVIDER, 0) +} + +func (s *Cloud_provider_params_autoContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Cloud_provider_params_autoContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Cloud_provider_params_autoContext) GCP_PUBSUB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCP_PUBSUB, 0) +} + +func (s *Cloud_provider_params_autoContext) GCP_PUBSUB_SUBSCRIPTION_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, 0) +} + +func (s *Cloud_provider_params_autoContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Cloud_provider_params_autoContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Cloud_provider_params_autoContext) AZURE_EVENT_GRID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_EVENT_GRID, 0) +} + +func (s *Cloud_provider_params_autoContext) AZURE_STORAGE_QUEUE_PRIMARY_URI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, 0) +} + +func (s *Cloud_provider_params_autoContext) AZURE_TENANT_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_TENANT_ID, 0) +} + +func (s *Cloud_provider_params_autoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cloud_provider_params_autoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cloud_provider_params_autoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCloud_provider_params_auto(s) + } +} + +func (s *Cloud_provider_params_autoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCloud_provider_params_auto(s) + } +} + +func (s *Cloud_provider_params_autoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCloud_provider_params_auto(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Cloud_provider_params_auto() (localctx ICloud_provider_params_autoContext) { + localctx = NewCloud_provider_params_autoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, SnowflakeParserRULE_cloud_provider_params_auto) + p.SetState(7048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 813, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7032) + p.Match(SnowflakeParserNOTIFICATION_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7033) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7034) + p.Match(SnowflakeParserGCP_PUBSUB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7035) + p.Match(SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7036) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7037) + p.String_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7038) + p.Match(SnowflakeParserNOTIFICATION_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7039) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7040) + p.Match(SnowflakeParserAZURE_EVENT_GRID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7041) + p.Match(SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7042) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7043) + p.String_() + } + { + p.SetState(7044) + p.Match(SnowflakeParserAZURE_TENANT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7045) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7046) + p.String_() + } + + 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 +} + +// ICloud_provider_params_pushContext is an interface to support dynamic dispatch. +type ICloud_provider_params_pushContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOTIFICATION_PROVIDER() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AWS_SNS() antlr.TerminalNode + AWS_SNS_TOPIC_ARN() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + AWS_SNS_ROLE_ARN() antlr.TerminalNode + GCP_PUBSUB() antlr.TerminalNode + GCP_PUBSUB_TOPIC_NAME() antlr.TerminalNode + AZURE_EVENT_GRID() antlr.TerminalNode + AZURE_EVENT_GRID_TOPIC_ENDPOINT() antlr.TerminalNode + AZURE_TENANT_ID() antlr.TerminalNode + + // IsCloud_provider_params_pushContext differentiates from other interfaces. + IsCloud_provider_params_pushContext() +} + +type Cloud_provider_params_pushContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCloud_provider_params_pushContext() *Cloud_provider_params_pushContext { + var p = new(Cloud_provider_params_pushContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params_push + return p +} + +func InitEmptyCloud_provider_params_pushContext(p *Cloud_provider_params_pushContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params_push +} + +func (*Cloud_provider_params_pushContext) IsCloud_provider_params_pushContext() {} + +func NewCloud_provider_params_pushContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cloud_provider_params_pushContext { + var p = new(Cloud_provider_params_pushContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params_push + + return p +} + +func (s *Cloud_provider_params_pushContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cloud_provider_params_pushContext) NOTIFICATION_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION_PROVIDER, 0) +} + +func (s *Cloud_provider_params_pushContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Cloud_provider_params_pushContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Cloud_provider_params_pushContext) AWS_SNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS, 0) +} + +func (s *Cloud_provider_params_pushContext) AWS_SNS_TOPIC_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS_TOPIC_ARN, 0) +} + +func (s *Cloud_provider_params_pushContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Cloud_provider_params_pushContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Cloud_provider_params_pushContext) AWS_SNS_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS_ROLE_ARN, 0) +} + +func (s *Cloud_provider_params_pushContext) GCP_PUBSUB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCP_PUBSUB, 0) +} + +func (s *Cloud_provider_params_pushContext) GCP_PUBSUB_TOPIC_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCP_PUBSUB_TOPIC_NAME, 0) +} + +func (s *Cloud_provider_params_pushContext) AZURE_EVENT_GRID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_EVENT_GRID, 0) +} + +func (s *Cloud_provider_params_pushContext) AZURE_EVENT_GRID_TOPIC_ENDPOINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, 0) +} + +func (s *Cloud_provider_params_pushContext) AZURE_TENANT_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_TENANT_ID, 0) +} + +func (s *Cloud_provider_params_pushContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cloud_provider_params_pushContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cloud_provider_params_pushContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCloud_provider_params_push(s) + } +} + +func (s *Cloud_provider_params_pushContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCloud_provider_params_push(s) + } +} + +func (s *Cloud_provider_params_pushContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCloud_provider_params_push(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Cloud_provider_params_push() (localctx ICloud_provider_params_pushContext) { + localctx = NewCloud_provider_params_pushContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, SnowflakeParserRULE_cloud_provider_params_push) + p.SetState(7076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 814, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7050) + p.Match(SnowflakeParserNOTIFICATION_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7051) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7052) + p.Match(SnowflakeParserAWS_SNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7053) + p.Match(SnowflakeParserAWS_SNS_TOPIC_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7054) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7055) + p.String_() + } + { + p.SetState(7056) + p.Match(SnowflakeParserAWS_SNS_ROLE_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7057) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7058) + p.String_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7060) + p.Match(SnowflakeParserNOTIFICATION_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7061) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7062) + p.Match(SnowflakeParserGCP_PUBSUB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7063) + p.Match(SnowflakeParserGCP_PUBSUB_TOPIC_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7064) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7065) + p.String_() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7066) + p.Match(SnowflakeParserNOTIFICATION_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7067) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7068) + p.Match(SnowflakeParserAZURE_EVENT_GRID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7069) + p.Match(SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7070) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7071) + p.String_() + } + { + p.SetState(7072) + p.Match(SnowflakeParserAZURE_TENANT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7073) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7074) + p.String_() + } + + 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_notification_integrationContext is an interface to support dynamic dispatch. +type ICreate_notification_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + ENABLED() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + True_false() ITrue_falseContext + TYPE() antlr.TerminalNode + QUEUE() antlr.TerminalNode + Cloud_provider_params_auto() ICloud_provider_params_autoContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + Comment_clause() IComment_clauseContext + DIRECTION() antlr.TerminalNode + OUTBOUND() antlr.TerminalNode + Cloud_provider_params_push() ICloud_provider_params_pushContext + + // IsCreate_notification_integrationContext differentiates from other interfaces. + IsCreate_notification_integrationContext() +} + +type Create_notification_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_notification_integrationContext() *Create_notification_integrationContext { + var p = new(Create_notification_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_notification_integration + return p +} + +func InitEmptyCreate_notification_integrationContext(p *Create_notification_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_notification_integration +} + +func (*Create_notification_integrationContext) IsCreate_notification_integrationContext() {} + +func NewCreate_notification_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_notification_integrationContext { + var p = new(Create_notification_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_notification_integration + + return p +} + +func (s *Create_notification_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_notification_integrationContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_notification_integrationContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION, 0) +} + +func (s *Create_notification_integrationContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Create_notification_integrationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_notification_integrationContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Create_notification_integrationContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_notification_integrationContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_notification_integrationContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_notification_integrationContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_notification_integrationContext) QUEUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUEUE, 0) +} + +func (s *Create_notification_integrationContext) Cloud_provider_params_auto() ICloud_provider_params_autoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICloud_provider_params_autoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICloud_provider_params_autoContext) +} + +func (s *Create_notification_integrationContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_notification_integrationContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_notification_integrationContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_notification_integrationContext) DIRECTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDIRECTION, 0) +} + +func (s *Create_notification_integrationContext) OUTBOUND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOUTBOUND, 0) +} + +func (s *Create_notification_integrationContext) Cloud_provider_params_push() ICloud_provider_params_pushContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICloud_provider_params_pushContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICloud_provider_params_pushContext) +} + +func (s *Create_notification_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_notification_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_notification_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_notification_integration(s) + } +} + +func (s *Create_notification_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_notification_integration(s) + } +} + +func (s *Create_notification_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_notification_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_notification_integration() (localctx ICreate_notification_integrationContext) { + localctx = NewCreate_notification_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, SnowflakeParserRULE_create_notification_integration) + var _la int + + p.SetState(7121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 821, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7078) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7079) + p.Or_replace() + } + + } + { + p.SetState(7082) + p.Match(SnowflakeParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7083) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7085) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 816, p.GetParserRuleContext()) == 1 { + { + p.SetState(7084) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7087) + p.Id_() + } + { + p.SetState(7088) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7089) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7090) + p.True_false() + } + { + p.SetState(7091) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7092) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7093) + p.Match(SnowflakeParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7094) + p.Cloud_provider_params_auto() + } + p.SetState(7096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7095) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7098) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7100) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7099) + p.Or_replace() + } + + } + { + p.SetState(7102) + p.Match(SnowflakeParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7103) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7105) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 819, p.GetParserRuleContext()) == 1 { + { + p.SetState(7104) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7107) + p.Id_() + } + { + p.SetState(7108) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7109) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7110) + p.True_false() + } + { + p.SetState(7111) + p.Match(SnowflakeParserDIRECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7112) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7113) + p.Match(SnowflakeParserOUTBOUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7114) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7115) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7116) + p.Match(SnowflakeParserQUEUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7117) + p.Cloud_provider_params_push() + } + p.SetState(7119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7118) + p.Comment_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 +} + +// ICreate_pipeContext is an interface to support dynamic dispatch. +type ICreate_pipeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PIPE() antlr.TerminalNode + Object_name() IObject_nameContext + AS() antlr.TerminalNode + Copy_into_table() ICopy_into_tableContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + AUTO_INGEST() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + True_false() ITrue_falseContext + ERROR_INTEGRATION() antlr.TerminalNode + Id_() IId_Context + AWS_SNS_TOPIC() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + INTEGRATION() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsCreate_pipeContext differentiates from other interfaces. + IsCreate_pipeContext() +} + +type Create_pipeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_pipeContext() *Create_pipeContext { + var p = new(Create_pipeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_pipe + return p +} + +func InitEmptyCreate_pipeContext(p *Create_pipeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_pipe +} + +func (*Create_pipeContext) IsCreate_pipeContext() {} + +func NewCreate_pipeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_pipeContext { + var p = new(Create_pipeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_pipe + + return p +} + +func (s *Create_pipeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_pipeContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_pipeContext) PIPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE, 0) +} + +func (s *Create_pipeContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_pipeContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_pipeContext) Copy_into_table() ICopy_into_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_into_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_into_tableContext) +} + +func (s *Create_pipeContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_pipeContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_pipeContext) AUTO_INGEST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_INGEST, 0) +} + +func (s *Create_pipeContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_pipeContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_pipeContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_pipeContext) ERROR_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_INTEGRATION, 0) +} + +func (s *Create_pipeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_pipeContext) AWS_SNS_TOPIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS_TOPIC, 0) +} + +func (s *Create_pipeContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_pipeContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_pipeContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Create_pipeContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_pipeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_pipeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_pipeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_pipe(s) + } +} + +func (s *Create_pipeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_pipe(s) + } +} + +func (s *Create_pipeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_pipe(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_pipe() (localctx ICreate_pipeContext) { + localctx = NewCreate_pipeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, SnowflakeParserRULE_create_pipe) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7123) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7124) + p.Or_replace() + } + + } + { + p.SetState(7127) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7129) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 823, p.GetParserRuleContext()) == 1 { + { + p.SetState(7128) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7131) + p.Object_name() + } + p.SetState(7135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAUTO_INGEST { + { + p.SetState(7132) + p.Match(SnowflakeParserAUTO_INGEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7133) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7134) + p.True_false() + } + + } + p.SetState(7140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserERROR_INTEGRATION { + { + p.SetState(7137) + p.Match(SnowflakeParserERROR_INTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7138) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7139) + p.Id_() + } + + } + p.SetState(7145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAWS_SNS_TOPIC { + { + p.SetState(7142) + p.Match(SnowflakeParserAWS_SNS_TOPIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7143) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7144) + p.String_() + } + + } + p.SetState(7150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserINTEGRATION { + { + p.SetState(7147) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7148) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7149) + p.String_() + } + + } + p.SetState(7153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7152) + p.Comment_clause() + } + + } + { + p.SetState(7155) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7156) + p.Copy_into_table() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICaller_ownerContext is an interface to support dynamic dispatch. +type ICaller_ownerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALLER() antlr.TerminalNode + OWNER() antlr.TerminalNode + + // IsCaller_ownerContext differentiates from other interfaces. + IsCaller_ownerContext() +} + +type Caller_ownerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCaller_ownerContext() *Caller_ownerContext { + var p = new(Caller_ownerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_caller_owner + return p +} + +func InitEmptyCaller_ownerContext(p *Caller_ownerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_caller_owner +} + +func (*Caller_ownerContext) IsCaller_ownerContext() {} + +func NewCaller_ownerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Caller_ownerContext { + var p = new(Caller_ownerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_caller_owner + + return p +} + +func (s *Caller_ownerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Caller_ownerContext) CALLER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCALLER, 0) +} + +func (s *Caller_ownerContext) OWNER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOWNER, 0) +} + +func (s *Caller_ownerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Caller_ownerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Caller_ownerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCaller_owner(s) + } +} + +func (s *Caller_ownerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCaller_owner(s) + } +} + +func (s *Caller_ownerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCaller_owner(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Caller_owner() (localctx ICaller_ownerContext) { + localctx = NewCaller_ownerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, SnowflakeParserRULE_caller_owner) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7158) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCALLER || _la == SnowflakeParserOWNER) { + 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 +} + +// IExecuta_asContext is an interface to support dynamic dispatch. +type IExecuta_asContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXECUTE() antlr.TerminalNode + AS() antlr.TerminalNode + Caller_owner() ICaller_ownerContext + + // IsExecuta_asContext differentiates from other interfaces. + IsExecuta_asContext() +} + +type Executa_asContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExecuta_asContext() *Executa_asContext { + var p = new(Executa_asContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_executa_as + return p +} + +func InitEmptyExecuta_asContext(p *Executa_asContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_executa_as +} + +func (*Executa_asContext) IsExecuta_asContext() {} + +func NewExecuta_asContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Executa_asContext { + var p = new(Executa_asContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_executa_as + + return p +} + +func (s *Executa_asContext) GetParser() antlr.Parser { return s.parser } + +func (s *Executa_asContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXECUTE, 0) +} + +func (s *Executa_asContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Executa_asContext) Caller_owner() ICaller_ownerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICaller_ownerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICaller_ownerContext) +} + +func (s *Executa_asContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Executa_asContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Executa_asContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExecuta_as(s) + } +} + +func (s *Executa_asContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExecuta_as(s) + } +} + +func (s *Executa_asContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExecuta_as(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Executa_as() (localctx IExecuta_asContext) { + localctx = NewExecuta_asContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, SnowflakeParserRULE_executa_as) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7160) + p.Match(SnowflakeParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7161) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7162) + p.Caller_owner() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProcedure_definitionContext is an interface to support dynamic dispatch. +type IProcedure_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + String_() IStringContext + DBL_DOLLAR() antlr.TerminalNode + + // IsProcedure_definitionContext differentiates from other interfaces. + IsProcedure_definitionContext() +} + +type Procedure_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_definitionContext() *Procedure_definitionContext { + var p = new(Procedure_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_procedure_definition + return p +} + +func InitEmptyProcedure_definitionContext(p *Procedure_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_procedure_definition +} + +func (*Procedure_definitionContext) IsProcedure_definitionContext() {} + +func NewProcedure_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_definitionContext { + var p = new(Procedure_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_procedure_definition + + return p +} + +func (s *Procedure_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_definitionContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Procedure_definitionContext) DBL_DOLLAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDBL_DOLLAR, 0) +} + +func (s *Procedure_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterProcedure_definition(s) + } +} + +func (s *Procedure_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitProcedure_definition(s) + } +} + +func (s *Procedure_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitProcedure_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Procedure_definition() (localctx IProcedure_definitionContext) { + localctx = NewProcedure_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, SnowflakeParserRULE_procedure_definition) + p.SetState(7166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7164) + p.String_() + } + + case SnowflakeParserDBL_DOLLAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7165) + p.Match(SnowflakeParserDBL_DOLLAR) + 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 +} + +// ICreate_procedureContext is an interface to support dynamic dispatch. +type ICreate_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + Object_name() IObject_nameContext + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + AllRETURNS() []antlr.TerminalNode + RETURNS(i int) antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + SQL() antlr.TerminalNode + AS() antlr.TerminalNode + Procedure_definition() IProcedure_definitionContext + Data_type() IData_typeContext + TABLE() antlr.TerminalNode + Or_replace() IOr_replaceContext + AllArg_decl() []IArg_declContext + Arg_decl(i int) IArg_declContext + NOT() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + CALLED() antlr.TerminalNode + ON() antlr.TerminalNode + INPUT() antlr.TerminalNode + STRICT() antlr.TerminalNode + Comment_clause() IComment_clauseContext + Executa_as() IExecuta_asContext + VOLATILE() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + AllCol_decl() []ICol_declContext + Col_decl(i int) ICol_declContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + JAVASCRIPT() antlr.TerminalNode + SECURE() antlr.TerminalNode + + // IsCreate_procedureContext differentiates from other interfaces. + IsCreate_procedureContext() +} + +type Create_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_procedureContext() *Create_procedureContext { + var p = new(Create_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_procedure + return p +} + +func InitEmptyCreate_procedureContext(p *Create_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_procedure +} + +func (*Create_procedureContext) IsCreate_procedureContext() {} + +func NewCreate_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_procedureContext { + var p = new(Create_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_procedure + + return p +} + +func (s *Create_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_procedureContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE, 0) +} + +func (s *Create_procedureContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_procedureContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_procedureContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_procedureContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_procedureContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_procedureContext) AllRETURNS() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRETURNS) +} + +func (s *Create_procedureContext) RETURNS(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURNS, i) +} + +func (s *Create_procedureContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLANGUAGE, 0) +} + +func (s *Create_procedureContext) SQL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSQL, 0) +} + +func (s *Create_procedureContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_procedureContext) Procedure_definition() IProcedure_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_definitionContext) +} + +func (s *Create_procedureContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Create_procedureContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Create_procedureContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_procedureContext) AllArg_decl() []IArg_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArg_declContext); ok { + len++ + } + } + + tst := make([]IArg_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArg_declContext); ok { + tst[i] = t.(IArg_declContext) + i++ + } + } + + return tst +} + +func (s *Create_procedureContext) Arg_decl(i int) IArg_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArg_declContext) +} + +func (s *Create_procedureContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *Create_procedureContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserNULL_) +} + +func (s *Create_procedureContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, i) +} + +func (s *Create_procedureContext) CALLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCALLED, 0) +} + +func (s *Create_procedureContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Create_procedureContext) INPUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINPUT, 0) +} + +func (s *Create_procedureContext) STRICT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRICT, 0) +} + +func (s *Create_procedureContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_procedureContext) Executa_as() IExecuta_asContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExecuta_asContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExecuta_asContext) +} + +func (s *Create_procedureContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVOLATILE, 0) +} + +func (s *Create_procedureContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMUTABLE, 0) +} + +func (s *Create_procedureContext) AllCol_decl() []ICol_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICol_declContext); ok { + len++ + } + } + + tst := make([]ICol_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICol_declContext); ok { + tst[i] = t.(ICol_declContext) + i++ + } + } + + return tst +} + +func (s *Create_procedureContext) Col_decl(i int) ICol_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICol_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICol_declContext) +} + +func (s *Create_procedureContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_procedureContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_procedureContext) JAVASCRIPT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJAVASCRIPT, 0) +} + +func (s *Create_procedureContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Create_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_procedure(s) + } +} + +func (s *Create_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_procedure(s) + } +} + +func (s *Create_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_procedure() (localctx ICreate_procedureContext) { + localctx = NewCreate_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 388, SnowflakeParserRULE_create_procedure) + var _la int + + p.SetState(7286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 850, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7168) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7169) + p.Or_replace() + } + + } + { + p.SetState(7172) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7173) + p.Object_name() + } + { + p.SetState(7174) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(7175) + p.Arg_decl() + } + p.SetState(7180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7176) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7177) + p.Arg_decl() + } + + p.SetState(7182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(7185) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7186) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserDOUBLE, SnowflakeParserINT, SnowflakeParserNUMBER, SnowflakeParserOBJECT, SnowflakeParserTIME, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserARRAY, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNUMERIC, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT: + { + p.SetState(7187) + p.Data_type() + } + + case SnowflakeParserTABLE: + { + p.SetState(7188) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7189) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(7190) + p.Col_decl() + } + p.SetState(7195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7191) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7192) + p.Col_decl() + } + + p.SetState(7197) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(7200) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(7203) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7204) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7207) + p.Match(SnowflakeParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7208) + p.Match(SnowflakeParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCALLED: + { + p.SetState(7209) + p.Match(SnowflakeParserCALLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7210) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7211) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7212) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRETURNS: + { + p.SetState(7213) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7214) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7215) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7216) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7217) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTRICT: + { + p.SetState(7218) + p.Match(SnowflakeParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAS, SnowflakeParserCOMMENT, SnowflakeParserEXECUTE, SnowflakeParserIMMUTABLE, SnowflakeParserVOLATILE: + + default: + } + p.SetState(7222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE { + { + p.SetState(7221) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(7225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7224) + p.Comment_clause() + } + + } + p.SetState(7228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXECUTE { + { + p.SetState(7227) + p.Executa_as() + } + + } + { + p.SetState(7230) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7231) + p.Procedure_definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7233) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7235) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7234) + p.Or_replace() + } + + } + p.SetState(7238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURE { + { + p.SetState(7237) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7240) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7241) + p.Object_name() + } + { + p.SetState(7242) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(7243) + p.Arg_decl() + } + p.SetState(7248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7244) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7245) + p.Arg_decl() + } + + p.SetState(7250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(7253) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7254) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7255) + p.Data_type() + } + p.SetState(7258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(7256) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7257) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7260) + p.Match(SnowflakeParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7261) + p.Match(SnowflakeParserJAVASCRIPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCALLED: + { + p.SetState(7262) + p.Match(SnowflakeParserCALLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7263) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7264) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7265) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRETURNS: + { + p.SetState(7266) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7267) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7268) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7269) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7270) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTRICT: + { + p.SetState(7271) + p.Match(SnowflakeParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAS, SnowflakeParserCOMMENT, SnowflakeParserEXECUTE, SnowflakeParserIMMUTABLE, SnowflakeParserVOLATILE: + + default: + } + p.SetState(7275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE { + { + p.SetState(7274) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserIMMUTABLE || _la == SnowflakeParserVOLATILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(7278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7277) + p.Comment_clause() + } + + } + p.SetState(7281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXECUTE { + { + p.SetState(7280) + p.Executa_as() + } + + } + { + p.SetState(7283) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7284) + p.Procedure_definition() + } + + 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_replication_groupContext is an interface to support dynamic dispatch. +type ICreate_replication_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + OBJECT_TYPES() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllObject_type() []IObject_typeContext + Object_type(i int) IObject_typeContext + ALLOWED_ACCOUNTS() antlr.TerminalNode + AllFull_acct() []IFull_acctContext + Full_acct(i int) IFull_acctContext + If_not_exists() IIf_not_existsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALLOWED_DATABASES() antlr.TerminalNode + ALLOWED_SHARES() antlr.TerminalNode + ALLOWED_INTEGRATION_TYPES() antlr.TerminalNode + AllIntegration_type_name() []IIntegration_type_nameContext + Integration_type_name(i int) IIntegration_type_nameContext + IGNORE() antlr.TerminalNode + EDITION() antlr.TerminalNode + CHECK() antlr.TerminalNode + REPLICATION_SCHEDULE() antlr.TerminalNode + String_() IStringContext + AS() antlr.TerminalNode + REPLICA() antlr.TerminalNode + OF() antlr.TerminalNode + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + + // IsCreate_replication_groupContext differentiates from other interfaces. + IsCreate_replication_groupContext() +} + +type Create_replication_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_replication_groupContext() *Create_replication_groupContext { + var p = new(Create_replication_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_replication_group + return p +} + +func InitEmptyCreate_replication_groupContext(p *Create_replication_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_replication_group +} + +func (*Create_replication_groupContext) IsCreate_replication_groupContext() {} + +func NewCreate_replication_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_replication_groupContext { + var p = new(Create_replication_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_replication_group + + return p +} + +func (s *Create_replication_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_replication_groupContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_replication_groupContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Create_replication_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Create_replication_groupContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_replication_groupContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_replication_groupContext) OBJECT_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT_TYPES, 0) +} + +func (s *Create_replication_groupContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_replication_groupContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_replication_groupContext) AllObject_type() []IObject_typeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_typeContext); ok { + len++ + } + } + + tst := make([]IObject_typeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_typeContext); ok { + tst[i] = t.(IObject_typeContext) + i++ + } + } + + return tst +} + +func (s *Create_replication_groupContext) Object_type(i int) IObject_typeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_typeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_typeContext) +} + +func (s *Create_replication_groupContext) ALLOWED_ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_ACCOUNTS, 0) +} + +func (s *Create_replication_groupContext) AllFull_acct() []IFull_acctContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFull_acctContext); ok { + len++ + } + } + + tst := make([]IFull_acctContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFull_acctContext); ok { + tst[i] = t.(IFull_acctContext) + i++ + } + } + + return tst +} + +func (s *Create_replication_groupContext) Full_acct(i int) IFull_acctContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_acctContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFull_acctContext) +} + +func (s *Create_replication_groupContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_replication_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_replication_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_replication_groupContext) ALLOWED_DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_DATABASES, 0) +} + +func (s *Create_replication_groupContext) ALLOWED_SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_SHARES, 0) +} + +func (s *Create_replication_groupContext) ALLOWED_INTEGRATION_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_INTEGRATION_TYPES, 0) +} + +func (s *Create_replication_groupContext) AllIntegration_type_name() []IIntegration_type_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIntegration_type_nameContext); ok { + len++ + } + } + + tst := make([]IIntegration_type_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIntegration_type_nameContext); ok { + tst[i] = t.(IIntegration_type_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_replication_groupContext) Integration_type_name(i int) IIntegration_type_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIntegration_type_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIntegration_type_nameContext) +} + +func (s *Create_replication_groupContext) IGNORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE, 0) +} + +func (s *Create_replication_groupContext) EDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEDITION, 0) +} + +func (s *Create_replication_groupContext) CHECK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHECK, 0) +} + +func (s *Create_replication_groupContext) REPLICATION_SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION_SCHEDULE, 0) +} + +func (s *Create_replication_groupContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_replication_groupContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_replication_groupContext) REPLICA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICA, 0) +} + +func (s *Create_replication_groupContext) OF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOF, 0) +} + +func (s *Create_replication_groupContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserDOT) +} + +func (s *Create_replication_groupContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, i) +} + +func (s *Create_replication_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_replication_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_replication_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_replication_group(s) + } +} + +func (s *Create_replication_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_replication_group(s) + } +} + +func (s *Create_replication_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_replication_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_replication_group() (localctx ICreate_replication_groupContext) { + localctx = NewCreate_replication_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, SnowflakeParserRULE_create_replication_group) + var _la int + + p.SetState(7377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 863, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7288) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7289) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7290) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7292) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 851, p.GetParserRuleContext()) == 1 { + { + p.SetState(7291) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7294) + p.Id_() + } + { + p.SetState(7295) + p.Match(SnowflakeParserOBJECT_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7296) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7297) + p.Object_type() + } + p.SetState(7302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7298) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7299) + p.Object_type() + } + + p.SetState(7304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(7315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOWED_DATABASES { + { + p.SetState(7305) + p.Match(SnowflakeParserALLOWED_DATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7306) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7307) + p.Id_() + } + p.SetState(7312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7308) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7309) + p.Id_() + } + + p.SetState(7314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7327) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOWED_SHARES { + { + p.SetState(7317) + p.Match(SnowflakeParserALLOWED_SHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7318) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7319) + p.Id_() + } + p.SetState(7324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7320) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7321) + p.Id_() + } + + p.SetState(7326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOWED_INTEGRATION_TYPES { + { + p.SetState(7329) + p.Match(SnowflakeParserALLOWED_INTEGRATION_TYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7330) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7331) + p.Integration_type_name() + } + p.SetState(7336) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7332) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7333) + p.Integration_type_name() + } + + p.SetState(7338) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(7341) + p.Match(SnowflakeParserALLOWED_ACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7342) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7343) + p.Full_acct() + } + p.SetState(7348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7344) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7345) + p.Full_acct() + } + + p.SetState(7350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(7354) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIGNORE { + { + p.SetState(7351) + p.Match(SnowflakeParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7352) + p.Match(SnowflakeParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7353) + p.Match(SnowflakeParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREPLICATION_SCHEDULE { + { + p.SetState(7356) + p.Match(SnowflakeParserREPLICATION_SCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7357) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7358) + p.String_() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7361) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7362) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7363) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7365) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 862, p.GetParserRuleContext()) == 1 { + { + p.SetState(7364) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7367) + p.Id_() + } + { + p.SetState(7368) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7369) + p.Match(SnowflakeParserREPLICA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7370) + p.Match(SnowflakeParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7371) + p.Id_() + } + { + p.SetState(7372) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7373) + p.Id_() + } + { + p.SetState(7374) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7375) + p.Id_() + } + + 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_resource_monitorContext is an interface to support dynamic dispatch. +type ICreate_resource_monitorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + MONITOR() antlr.TerminalNode + Id_() IId_Context + WITH() antlr.TerminalNode + Or_replace() IOr_replaceContext + Credit_quota() ICredit_quotaContext + Frequency() IFrequencyContext + START_TIMESTAMP() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + END_TIMESTAMP() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + Notify_users() INotify_usersContext + TRIGGERS() antlr.TerminalNode + IMMEDIATELY() antlr.TerminalNode + AllTrigger_definition() []ITrigger_definitionContext + Trigger_definition(i int) ITrigger_definitionContext + + // IsCreate_resource_monitorContext differentiates from other interfaces. + IsCreate_resource_monitorContext() +} + +type Create_resource_monitorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_resource_monitorContext() *Create_resource_monitorContext { + var p = new(Create_resource_monitorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_resource_monitor + return p +} + +func InitEmptyCreate_resource_monitorContext(p *Create_resource_monitorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_resource_monitor +} + +func (*Create_resource_monitorContext) IsCreate_resource_monitorContext() {} + +func NewCreate_resource_monitorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_resource_monitorContext { + var p = new(Create_resource_monitorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_resource_monitor + + return p +} + +func (s *Create_resource_monitorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_resource_monitorContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_resource_monitorContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE, 0) +} + +func (s *Create_resource_monitorContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Create_resource_monitorContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_resource_monitorContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Create_resource_monitorContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_resource_monitorContext) Credit_quota() ICredit_quotaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICredit_quotaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICredit_quotaContext) +} + +func (s *Create_resource_monitorContext) Frequency() IFrequencyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFrequencyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFrequencyContext) +} + +func (s *Create_resource_monitorContext) START_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTART_TIMESTAMP, 0) +} + +func (s *Create_resource_monitorContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_resource_monitorContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_resource_monitorContext) END_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEND_TIMESTAMP, 0) +} + +func (s *Create_resource_monitorContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_resource_monitorContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_resource_monitorContext) Notify_users() INotify_usersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INotify_usersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INotify_usersContext) +} + +func (s *Create_resource_monitorContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRIGGERS, 0) +} + +func (s *Create_resource_monitorContext) IMMEDIATELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMEDIATELY, 0) +} + +func (s *Create_resource_monitorContext) AllTrigger_definition() []ITrigger_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrigger_definitionContext); ok { + len++ + } + } + + tst := make([]ITrigger_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrigger_definitionContext); ok { + tst[i] = t.(ITrigger_definitionContext) + i++ + } + } + + return tst +} + +func (s *Create_resource_monitorContext) Trigger_definition(i int) ITrigger_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_definitionContext) +} + +func (s *Create_resource_monitorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_resource_monitorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_resource_monitorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_resource_monitor(s) + } +} + +func (s *Create_resource_monitorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_resource_monitor(s) + } +} + +func (s *Create_resource_monitorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_resource_monitor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_resource_monitor() (localctx ICreate_resource_monitorContext) { + localctx = NewCreate_resource_monitorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, SnowflakeParserRULE_create_resource_monitor) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7379) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7380) + p.Or_replace() + } + + } + { + p.SetState(7383) + p.Match(SnowflakeParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7384) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7385) + p.Id_() + } + { + p.SetState(7386) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCREDIT_QUOTA { + { + p.SetState(7387) + p.Credit_quota() + } + + } + p.SetState(7391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFREQUENCY { + { + p.SetState(7390) + p.Frequency() + } + + } + p.SetState(7399) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTART_TIMESTAMP { + { + p.SetState(7393) + p.Match(SnowflakeParserSTART_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7394) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7397) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7395) + p.String_() + } + + case SnowflakeParserIMMEDIATELY: + { + p.SetState(7396) + p.Match(SnowflakeParserIMMEDIATELY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(7404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEND_TIMESTAMP { + { + p.SetState(7401) + p.Match(SnowflakeParserEND_TIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7402) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7403) + p.String_() + } + + } + p.SetState(7407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFY_USERS { + { + p.SetState(7406) + p.Notify_users() + } + + } + p.SetState(7415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTRIGGERS { + { + p.SetState(7409) + p.Match(SnowflakeParserTRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserON { + { + p.SetState(7410) + p.Trigger_definition() + } + + p.SetState(7413) + 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_roleContext is an interface to support dynamic dispatch. +type ICreate_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ROLE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + TAG() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllSTRING() []antlr.TerminalNode + STRING(i int) antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + COMMENT() antlr.TerminalNode + WITH() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_roleContext differentiates from other interfaces. + IsCreate_roleContext() +} + +type Create_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_roleContext() *Create_roleContext { + var p = new(Create_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_role + return p +} + +func InitEmptyCreate_roleContext(p *Create_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_role +} + +func (*Create_roleContext) IsCreate_roleContext() {} + +func NewCreate_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_roleContext { + var p = new(Create_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_role + + return p +} + +func (s *Create_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_roleContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Create_roleContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Create_roleContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_roleContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_roleContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_roleContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Create_roleContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Create_roleContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_roleContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_roleContext) AllSTRING() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserSTRING) +} + +func (s *Create_roleContext) STRING(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING, i) +} + +func (s *Create_roleContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Create_roleContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Create_roleContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Create_roleContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_roleContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_role(s) + } +} + +func (s *Create_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_role(s) + } +} + +func (s *Create_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_role() (localctx ICreate_roleContext) { + localctx = NewCreate_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, SnowflakeParserRULE_create_role) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7417) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7418) + p.Or_replace() + } + + } + { + p.SetState(7421) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7423) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 874, p.GetParserRuleContext()) == 1 { + { + p.SetState(7422) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7425) + p.Id_() + } + p.SetState(7446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + p.SetState(7427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(7426) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7429) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7430) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7431) + p.Id_() + } + { + p.SetState(7432) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7433) + p.Match(SnowflakeParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7434) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7435) + p.Id_() + } + { + p.SetState(7436) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7437) + p.Match(SnowflakeParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(7443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7444) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7448) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7449) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7450) + p.Match(SnowflakeParserSTRING) + 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 +} + +// ICreate_row_access_policyContext is an interface to support dynamic dispatch. +type ICreate_row_access_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + AS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllArg_decl() []IArg_declContext + Arg_decl(i int) IArg_declContext + RR_BRACKET() antlr.TerminalNode + RETURNS() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + ARROW() antlr.TerminalNode + Expr() IExprContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsCreate_row_access_policyContext differentiates from other interfaces. + IsCreate_row_access_policyContext() +} + +type Create_row_access_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_row_access_policyContext() *Create_row_access_policyContext { + var p = new(Create_row_access_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_row_access_policy + return p +} + +func InitEmptyCreate_row_access_policyContext(p *Create_row_access_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_row_access_policy +} + +func (*Create_row_access_policyContext) IsCreate_row_access_policyContext() {} + +func NewCreate_row_access_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_row_access_policyContext { + var p = new(Create_row_access_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_row_access_policy + + return p +} + +func (s *Create_row_access_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_row_access_policyContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_row_access_policyContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Create_row_access_policyContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Create_row_access_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Create_row_access_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_row_access_policyContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_row_access_policyContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Create_row_access_policyContext) AllArg_decl() []IArg_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArg_declContext); ok { + len++ + } + } + + tst := make([]IArg_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArg_declContext); ok { + tst[i] = t.(IArg_declContext) + i++ + } + } + + return tst +} + +func (s *Create_row_access_policyContext) Arg_decl(i int) IArg_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArg_declContext) +} + +func (s *Create_row_access_policyContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Create_row_access_policyContext) RETURNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURNS, 0) +} + +func (s *Create_row_access_policyContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBOOLEAN, 0) +} + +func (s *Create_row_access_policyContext) ARROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARROW, 0) +} + +func (s *Create_row_access_policyContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Create_row_access_policyContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_row_access_policyContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_row_access_policyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_row_access_policyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_row_access_policyContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_row_access_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_row_access_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_row_access_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_row_access_policy(s) + } +} + +func (s *Create_row_access_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_row_access_policy(s) + } +} + +func (s *Create_row_access_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_row_access_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_row_access_policy() (localctx ICreate_row_access_policyContext) { + localctx = NewCreate_row_access_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 396, SnowflakeParserRULE_create_row_access_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7453) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7454) + p.Or_replace() + } + + } + { + p.SetState(7457) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7458) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7459) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7461) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 880, p.GetParserRuleContext()) == 1 { + { + p.SetState(7460) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7463) + p.Id_() + } + { + p.SetState(7464) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7465) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7466) + p.Arg_decl() + } + p.SetState(7471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(7467) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7468) + p.Arg_decl() + } + + p.SetState(7473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7474) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7475) + p.Match(SnowflakeParserRETURNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7476) + p.Match(SnowflakeParserBOOLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7477) + p.Match(SnowflakeParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7478) + p.expr(0) + } + p.SetState(7480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7479) + p.Comment_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 +} + +// ICreate_schemaContext is an interface to support dynamic dispatch. +type ICreate_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + Or_replace() IOr_replaceContext + TRANSIENT() antlr.TerminalNode + If_not_exists() IIf_not_existsContext + Clone_at_before() IClone_at_beforeContext + WITH() antlr.TerminalNode + MANAGED() antlr.TerminalNode + ACCESS() antlr.TerminalNode + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + Default_ddl_collation() IDefault_ddl_collationContext + With_tags() IWith_tagsContext + Comment_clause() IComment_clauseContext + + // IsCreate_schemaContext differentiates from other interfaces. + IsCreate_schemaContext() +} + +type Create_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_schemaContext() *Create_schemaContext { + var p = new(Create_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_schema + return p +} + +func InitEmptyCreate_schemaContext(p *Create_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_schema +} + +func (*Create_schemaContext) IsCreate_schemaContext() {} + +func NewCreate_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_schemaContext { + var p = new(Create_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_schema + + return p +} + +func (s *Create_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_schemaContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_schemaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Create_schemaContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Create_schemaContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_schemaContext) TRANSIENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSIENT, 0) +} + +func (s *Create_schemaContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_schemaContext) Clone_at_before() IClone_at_beforeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClone_at_beforeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClone_at_beforeContext) +} + +func (s *Create_schemaContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Create_schemaContext) MANAGED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMANAGED, 0) +} + +func (s *Create_schemaContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Create_schemaContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Create_schemaContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_schemaContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_schemaContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Create_schemaContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Create_schemaContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Create_schemaContext) Default_ddl_collation() IDefault_ddl_collationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_ddl_collationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_ddl_collationContext) +} + +func (s *Create_schemaContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Create_schemaContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_schema(s) + } +} + +func (s *Create_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_schema(s) + } +} + +func (s *Create_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_schema() (localctx ICreate_schemaContext) { + localctx = NewCreate_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 398, SnowflakeParserRULE_create_schema) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7482) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7483) + p.Or_replace() + } + + } + p.SetState(7487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTRANSIENT { + { + p.SetState(7486) + p.Match(SnowflakeParserTRANSIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7489) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7491) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 885, p.GetParserRuleContext()) == 1 { + { + p.SetState(7490) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7493) + p.Schema_name() + } + p.SetState(7495) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCLONE { + { + p.SetState(7494) + p.Clone_at_before() + } + + } + p.SetState(7500) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 887, p.GetParserRuleContext()) == 1 { + { + p.SetState(7497) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7498) + p.Match(SnowflakeParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7499) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDATA_RETENTION_TIME_IN_DAYS { + { + p.SetState(7502) + p.Match(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7503) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7504) + p.Num() + } + + } + p.SetState(7510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS { + { + p.SetState(7507) + p.Match(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7508) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7509) + p.Num() + } + + } + p.SetState(7513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDEFAULT_DDL_COLLATION_ { + { + p.SetState(7512) + p.Default_ddl_collation() + } + + } + p.SetState(7516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(7515) + p.With_tags() + } + + } + p.SetState(7519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7518) + p.Comment_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 +} + +// ICreate_security_integration_external_oauthContext is an interface to support dynamic dispatch. +type ICreate_security_integration_external_oauthContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + TYPE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + EXTERNAL_OAUTH() antlr.TerminalNode + ENABLED() antlr.TerminalNode + True_false() ITrue_falseContext + EXTERNAL_OAUTH_TYPE() antlr.TerminalNode + EXTERNAL_OAUTH_ISSUER() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM() antlr.TerminalNode + EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE() antlr.TerminalNode + OKTA() antlr.TerminalNode + AZURE() antlr.TerminalNode + PING_FEDERATE() antlr.TerminalNode + CUSTOM() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllString_list() []IString_listContext + String_list(i int) IString_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + AllEXTERNAL_OAUTH_JWS_KEYS_URL() []antlr.TerminalNode + EXTERNAL_OAUTH_JWS_KEYS_URL(i int) antlr.TerminalNode + EXTERNAL_OAUTH_BLOCKED_ROLES_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_ALLOWED_ROLES_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_RSA_PUBLIC_KEY() antlr.TerminalNode + EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2() antlr.TerminalNode + EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_ANY_ROLE_MODE() antlr.TerminalNode + EXTERNAL_OAUTH_SCOPE_DELIMITER() antlr.TerminalNode + DISABLE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENABLE_FOR_PRIVILEGE() antlr.TerminalNode + + // IsCreate_security_integration_external_oauthContext differentiates from other interfaces. + IsCreate_security_integration_external_oauthContext() +} + +type Create_security_integration_external_oauthContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_security_integration_external_oauthContext() *Create_security_integration_external_oauthContext { + var p = new(Create_security_integration_external_oauthContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_security_integration_external_oauth + return p +} + +func InitEmptyCreate_security_integration_external_oauthContext(p *Create_security_integration_external_oauthContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_security_integration_external_oauth +} + +func (*Create_security_integration_external_oauthContext) IsCreate_security_integration_external_oauthContext() { +} + +func NewCreate_security_integration_external_oauthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_security_integration_external_oauthContext { + var p = new(Create_security_integration_external_oauthContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_security_integration_external_oauth + + return p +} + +func (s *Create_security_integration_external_oauthContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_security_integration_external_oauthContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_security_integration_external_oauthContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Create_security_integration_external_oauthContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Create_security_integration_external_oauthContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_security_integration_external_oauthContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_security_integration_external_oauthContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_security_integration_external_oauthContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH, 0) +} + +func (s *Create_security_integration_external_oauthContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Create_security_integration_external_oauthContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_TYPE, 0) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_ISSUER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ISSUER, 0) +} + +func (s *Create_security_integration_external_oauthContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_security_integration_external_oauthContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, 0) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, 0) +} + +func (s *Create_security_integration_external_oauthContext) OKTA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOKTA, 0) +} + +func (s *Create_security_integration_external_oauthContext) AZURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE, 0) +} + +func (s *Create_security_integration_external_oauthContext) PING_FEDERATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPING_FEDERATE, 0) +} + +func (s *Create_security_integration_external_oauthContext) CUSTOM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCUSTOM, 0) +} + +func (s *Create_security_integration_external_oauthContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_security_integration_external_oauthContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_security_integration_external_oauthContext) AllString_list() []IString_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_listContext); ok { + len++ + } + } + + tst := make([]IString_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_listContext); ok { + tst[i] = t.(IString_listContext) + i++ + } + } + + return tst +} + +func (s *Create_security_integration_external_oauthContext) String_list(i int) IString_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Create_security_integration_external_oauthContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_security_integration_external_oauthContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_security_integration_external_oauthContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_security_integration_external_oauthContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_security_integration_external_oauthContext) AllEXTERNAL_OAUTH_JWS_KEYS_URL() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_JWS_KEYS_URL(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, i) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_BLOCKED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, 0) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_ALLOWED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, 0) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, 0) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_RSA_PUBLIC_KEY_2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2, 0) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, 0) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_ANY_ROLE_MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, 0) +} + +func (s *Create_security_integration_external_oauthContext) EXTERNAL_OAUTH_SCOPE_DELIMITER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, 0) +} + +func (s *Create_security_integration_external_oauthContext) DISABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE, 0) +} + +func (s *Create_security_integration_external_oauthContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *Create_security_integration_external_oauthContext) ENABLE_FOR_PRIVILEGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_FOR_PRIVILEGE, 0) +} + +func (s *Create_security_integration_external_oauthContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_security_integration_external_oauthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_security_integration_external_oauthContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_security_integration_external_oauth(s) + } +} + +func (s *Create_security_integration_external_oauthContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_security_integration_external_oauth(s) + } +} + +func (s *Create_security_integration_external_oauthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_security_integration_external_oauth(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_security_integration_external_oauth() (localctx ICreate_security_integration_external_oauthContext) { + localctx = NewCreate_security_integration_external_oauthContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, SnowflakeParserRULE_create_security_integration_external_oauth) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7521) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7522) + p.Or_replace() + } + + } + { + p.SetState(7525) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7526) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7528) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) == 1 { + { + p.SetState(7527) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7530) + p.Id_() + } + { + p.SetState(7531) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7532) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7533) + p.Match(SnowflakeParserEXTERNAL_OAUTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7534) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7535) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7536) + p.True_false() + } + { + p.SetState(7537) + p.Match(SnowflakeParserEXTERNAL_OAUTH_TYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7538) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7539) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAZURE || _la == SnowflakeParserCUSTOM || _la == SnowflakeParserOKTA || _la == SnowflakeParserPING_FEDERATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7540) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ISSUER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7541) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7542) + p.String_() + } + { + p.SetState(7543) + p.Match(SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7544) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7545) + p.String_() + } + + case SnowflakeParserLR_BRACKET: + { + p.SetState(7546) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7547) + p.String_list() + } + { + p.SetState(7548) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7552) + p.Match(SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7553) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7554) + p.String_() + } + p.SetState(7558) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 896, p.GetParserRuleContext()) == 1 { + { + p.SetState(7555) + p.Match(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7556) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7557) + p.String_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL { + { + p.SetState(7560) + p.Match(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7561) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7562) + p.String_() + } + + case SnowflakeParserLR_BRACKET: + { + p.SetState(7563) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7564) + p.String_list() + } + { + p.SetState(7565) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(7577) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST { + { + p.SetState(7571) + p.Match(SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7572) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7573) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7574) + p.String_list() + } + { + p.SetState(7575) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST { + { + p.SetState(7579) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7580) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7581) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7582) + p.String_list() + } + { + p.SetState(7583) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY { + { + p.SetState(7587) + p.Match(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7588) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7589) + p.String_() + } + + } + p.SetState(7595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2 { + { + p.SetState(7592) + p.Match(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY_2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7593) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7594) + p.String_() + } + + } + p.SetState(7603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST { + { + p.SetState(7597) + p.Match(SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7598) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7599) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7600) + p.String_() + } + { + p.SetState(7601) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE { + { + p.SetState(7605) + p.Match(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7606) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7607) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-239)) & ^0x3f) == 0 && ((int64(1)<<(_la-239))&1310721) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(7613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER { + { + p.SetState(7610) + p.Match(SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7611) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7612) + p.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 +} + +// IImplicit_noneContext is an interface to support dynamic dispatch. +type IImplicit_noneContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IMPLICIT() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsImplicit_noneContext differentiates from other interfaces. + IsImplicit_noneContext() +} + +type Implicit_noneContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImplicit_noneContext() *Implicit_noneContext { + var p = new(Implicit_noneContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_implicit_none + return p +} + +func InitEmptyImplicit_noneContext(p *Implicit_noneContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_implicit_none +} + +func (*Implicit_noneContext) IsImplicit_noneContext() {} + +func NewImplicit_noneContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implicit_noneContext { + var p = new(Implicit_noneContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_implicit_none + + return p +} + +func (s *Implicit_noneContext) GetParser() antlr.Parser { return s.parser } + +func (s *Implicit_noneContext) IMPLICIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMPLICIT, 0) +} + +func (s *Implicit_noneContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *Implicit_noneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Implicit_noneContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Implicit_noneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterImplicit_none(s) + } +} + +func (s *Implicit_noneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitImplicit_none(s) + } +} + +func (s *Implicit_noneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitImplicit_none(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Implicit_none() (localctx IImplicit_noneContext) { + localctx = NewImplicit_noneContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, SnowflakeParserRULE_implicit_none) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7615) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserIMPLICIT || _la == SnowflakeParserNONE) { + 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 +} + +// ICreate_security_integration_snowflake_oauthContext is an interface to support dynamic dispatch. +type ICreate_security_integration_snowflake_oauthContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + TYPE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + OAUTH() antlr.TerminalNode + OAUTH_CLIENT() antlr.TerminalNode + Partner_application() IPartner_applicationContext + OAUTH_REDIRECT_URI() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + Enabled_true_false() IEnabled_true_falseContext + OAUTH_ISSUE_REFRESH_TOKENS() antlr.TerminalNode + AllTrue_false() []ITrue_falseContext + True_false(i int) ITrue_falseContext + OAUTH_REFRESH_TOKEN_VALIDITY() antlr.TerminalNode + Num() INumContext + OAUTH_USE_SECONDARY_ROLES() antlr.TerminalNode + Implicit_none() IImplicit_noneContext + BLOCKED_ROLES_LIST() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllString_list() []IString_listContext + String_list(i int) IString_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Comment_clause() IComment_clauseContext + CUSTOM() antlr.TerminalNode + OAUTH_ALLOW_NON_TLS_REDIRECT_URI() antlr.TerminalNode + OAUTH_ENFORCE_PKCE() antlr.TerminalNode + PRE_AUTHORIZED_ROLES_LIST() antlr.TerminalNode + Network_policy() INetwork_policyContext + OAUTH_CLIENT_RSA_PUBLIC_KEY() antlr.TerminalNode + OAUTH_CLIENT_RSA_PUBLIC_KEY_2() antlr.TerminalNode + + // IsCreate_security_integration_snowflake_oauthContext differentiates from other interfaces. + IsCreate_security_integration_snowflake_oauthContext() +} + +type Create_security_integration_snowflake_oauthContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_security_integration_snowflake_oauthContext() *Create_security_integration_snowflake_oauthContext { + var p = new(Create_security_integration_snowflake_oauthContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_security_integration_snowflake_oauth + return p +} + +func InitEmptyCreate_security_integration_snowflake_oauthContext(p *Create_security_integration_snowflake_oauthContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_security_integration_snowflake_oauth +} + +func (*Create_security_integration_snowflake_oauthContext) IsCreate_security_integration_snowflake_oauthContext() { +} + +func NewCreate_security_integration_snowflake_oauthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_security_integration_snowflake_oauthContext { + var p = new(Create_security_integration_snowflake_oauthContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_security_integration_snowflake_oauth + + return p +} + +func (s *Create_security_integration_snowflake_oauthContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Create_security_integration_snowflake_oauthContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_security_integration_snowflake_oauthContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_security_integration_snowflake_oauthContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_CLIENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_CLIENT, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) Partner_application() IPartner_applicationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartner_applicationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartner_applicationContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_REDIRECT_URI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_REDIRECT_URI, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_security_integration_snowflake_oauthContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) Enabled_true_false() IEnabled_true_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnabled_true_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnabled_true_falseContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_ISSUE_REFRESH_TOKENS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) AllTrue_false() []ITrue_falseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrue_falseContext); ok { + len++ + } + } + + tst := make([]ITrue_falseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrue_falseContext); ok { + tst[i] = t.(ITrue_falseContext) + i++ + } + } + + return tst +} + +func (s *Create_security_integration_snowflake_oauthContext) True_false(i int) ITrue_falseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_REFRESH_TOKEN_VALIDITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_USE_SECONDARY_ROLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_USE_SECONDARY_ROLES, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) Implicit_none() IImplicit_noneContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplicit_noneContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplicit_noneContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) BLOCKED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBLOCKED_ROLES_LIST, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_security_integration_snowflake_oauthContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_security_integration_snowflake_oauthContext) AllString_list() []IString_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_listContext); ok { + len++ + } + } + + tst := make([]IString_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_listContext); ok { + tst[i] = t.(IString_listContext) + i++ + } + } + + return tst +} + +func (s *Create_security_integration_snowflake_oauthContext) String_list(i int) IString_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_security_integration_snowflake_oauthContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_security_integration_snowflake_oauthContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) CUSTOM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCUSTOM, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_ALLOW_NON_TLS_REDIRECT_URI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_ENFORCE_PKCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_ENFORCE_PKCE, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) PRE_AUTHORIZED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) Network_policy() INetwork_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INetwork_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INetwork_policyContext) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_CLIENT_RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) OAUTH_CLIENT_RSA_PUBLIC_KEY_2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY_2, 0) +} + +func (s *Create_security_integration_snowflake_oauthContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_security_integration_snowflake_oauthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_security_integration_snowflake_oauthContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_security_integration_snowflake_oauth(s) + } +} + +func (s *Create_security_integration_snowflake_oauthContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_security_integration_snowflake_oauth(s) + } +} + +func (s *Create_security_integration_snowflake_oauthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_security_integration_snowflake_oauth(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_security_integration_snowflake_oauth() (localctx ICreate_security_integration_snowflake_oauthContext) { + localctx = NewCreate_security_integration_snowflake_oauthContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, SnowflakeParserRULE_create_security_integration_snowflake_oauth) + var _la int + + p.SetState(7744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 928, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7617) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7618) + p.Or_replace() + } + + } + { + p.SetState(7621) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7622) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7624) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 907, p.GetParserRuleContext()) == 1 { + { + p.SetState(7623) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7626) + p.Id_() + } + { + p.SetState(7627) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7628) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7629) + p.Match(SnowflakeParserOAUTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7630) + p.Match(SnowflakeParserOAUTH_CLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7631) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7632) + p.Partner_application() + } + { + p.SetState(7633) + p.Match(SnowflakeParserOAUTH_REDIRECT_URI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7634) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7635) + p.String_() + } + p.SetState(7637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(7636) + p.Enabled_true_false() + } + + } + p.SetState(7642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS { + { + p.SetState(7639) + p.Match(SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7640) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7641) + p.True_false() + } + + } + p.SetState(7647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY { + { + p.SetState(7644) + p.Match(SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7645) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7646) + p.Num() + } + + } + p.SetState(7652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_USE_SECONDARY_ROLES { + { + p.SetState(7649) + p.Match(SnowflakeParserOAUTH_USE_SECONDARY_ROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7650) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7651) + p.Implicit_none() + } + + } + p.SetState(7660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserBLOCKED_ROLES_LIST { + { + p.SetState(7654) + p.Match(SnowflakeParserBLOCKED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7655) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7656) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7657) + p.String_list() + } + { + p.SetState(7658) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7662) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7665) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7666) + p.Or_replace() + } + + } + { + p.SetState(7669) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7670) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7672) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 915, p.GetParserRuleContext()) == 1 { + { + p.SetState(7671) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7674) + p.Id_() + } + { + p.SetState(7675) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7676) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7677) + p.Match(SnowflakeParserOAUTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7678) + p.Match(SnowflakeParserOAUTH_CLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7679) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7680) + p.Match(SnowflakeParserCUSTOM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7681) + p.Match(SnowflakeParserOAUTH_REDIRECT_URI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7682) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7683) + p.String_() + } + p.SetState(7685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENABLED { + { + p.SetState(7684) + p.Enabled_true_false() + } + + } + p.SetState(7690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI { + { + p.SetState(7687) + p.Match(SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7688) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7689) + p.True_false() + } + + } + p.SetState(7695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_ENFORCE_PKCE { + { + p.SetState(7692) + p.Match(SnowflakeParserOAUTH_ENFORCE_PKCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7693) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7694) + p.True_false() + } + + } + p.SetState(7700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_USE_SECONDARY_ROLES { + { + p.SetState(7697) + p.Match(SnowflakeParserOAUTH_USE_SECONDARY_ROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7698) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7699) + p.Implicit_none() + } + + } + p.SetState(7708) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPRE_AUTHORIZED_ROLES_LIST { + { + p.SetState(7702) + p.Match(SnowflakeParserPRE_AUTHORIZED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7703) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7704) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7705) + p.String_list() + } + { + p.SetState(7706) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserBLOCKED_ROLES_LIST { + { + p.SetState(7710) + p.Match(SnowflakeParserBLOCKED_ROLES_LIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7711) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7712) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7713) + p.String_list() + } + { + p.SetState(7714) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS { + { + p.SetState(7718) + p.Match(SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7719) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7720) + p.True_false() + } + + } + p.SetState(7726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY { + { + p.SetState(7723) + p.Match(SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7724) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7725) + p.Num() + } + + } + p.SetState(7729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNETWORK_POLICY { + { + p.SetState(7728) + p.Network_policy() + } + + } + p.SetState(7734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY { + { + p.SetState(7731) + p.Match(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7732) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7733) + p.String_() + } + + } + p.SetState(7739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY_2 { + { + p.SetState(7736) + p.Match(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY_2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7737) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7738) + p.String_() + } + + } + p.SetState(7742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7741) + p.Comment_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 +} + +// ICreate_security_integration_saml2Context is an interface to support dynamic dispatch. +type ICreate_security_integration_saml2Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + TYPE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + SAML2() antlr.TerminalNode + Enabled_true_false() IEnabled_true_falseContext + SAML2_ISSUER() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + SAML2_SSO_URL() antlr.TerminalNode + SAML2_PROVIDER() antlr.TerminalNode + SAML2_X509_CERT() antlr.TerminalNode + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + SAML2_SP_INITIATED_LOGIN_PAGE_LABEL() antlr.TerminalNode + SAML2_ENABLE_SP_INITIATED() antlr.TerminalNode + AllTrue_false() []ITrue_falseContext + True_false(i int) ITrue_falseContext + SAML2_SNOWFLAKE_X509_CERT() antlr.TerminalNode + SAML2_SIGN_REQUEST() antlr.TerminalNode + SAML2_REQUESTED_NAMEID_FORMAT() antlr.TerminalNode + SAML2_POST_LOGOUT_REDIRECT_URL() antlr.TerminalNode + SAML2_FORCE_AUTHN() antlr.TerminalNode + SAML2_SNOWFLAKE_ISSUER_URL() antlr.TerminalNode + SAML2_SNOWFLAKE_ACS_URL() antlr.TerminalNode + + // IsCreate_security_integration_saml2Context differentiates from other interfaces. + IsCreate_security_integration_saml2Context() +} + +type Create_security_integration_saml2Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_security_integration_saml2Context() *Create_security_integration_saml2Context { + var p = new(Create_security_integration_saml2Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_security_integration_saml2 + return p +} + +func InitEmptyCreate_security_integration_saml2Context(p *Create_security_integration_saml2Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_security_integration_saml2 +} + +func (*Create_security_integration_saml2Context) IsCreate_security_integration_saml2Context() {} + +func NewCreate_security_integration_saml2Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_security_integration_saml2Context { + var p = new(Create_security_integration_saml2Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_security_integration_saml2 + + return p +} + +func (s *Create_security_integration_saml2Context) GetParser() antlr.Parser { return s.parser } + +func (s *Create_security_integration_saml2Context) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_security_integration_saml2Context) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Create_security_integration_saml2Context) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Create_security_integration_saml2Context) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_security_integration_saml2Context) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_security_integration_saml2Context) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_security_integration_saml2Context) SAML2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2, 0) +} + +func (s *Create_security_integration_saml2Context) Enabled_true_false() IEnabled_true_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnabled_true_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnabled_true_falseContext) +} + +func (s *Create_security_integration_saml2Context) SAML2_ISSUER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_ISSUER, 0) +} + +func (s *Create_security_integration_saml2Context) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_security_integration_saml2Context) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_security_integration_saml2Context) SAML2_SSO_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SSO_URL, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_PROVIDER, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_X509_CERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_X509_CERT, 0) +} + +func (s *Create_security_integration_saml2Context) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_security_integration_saml2Context) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_security_integration_saml2Context) SAML2_SP_INITIATED_LOGIN_PAGE_LABEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SP_INITIATED_LOGIN_PAGE_LABEL, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_ENABLE_SP_INITIATED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_ENABLE_SP_INITIATED, 0) +} + +func (s *Create_security_integration_saml2Context) AllTrue_false() []ITrue_falseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrue_falseContext); ok { + len++ + } + } + + tst := make([]ITrue_falseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrue_falseContext); ok { + tst[i] = t.(ITrue_falseContext) + i++ + } + } + + return tst +} + +func (s *Create_security_integration_saml2Context) True_false(i int) ITrue_falseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_security_integration_saml2Context) SAML2_SNOWFLAKE_X509_CERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SNOWFLAKE_X509_CERT, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_SIGN_REQUEST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SIGN_REQUEST, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_REQUESTED_NAMEID_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_REQUESTED_NAMEID_FORMAT, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_POST_LOGOUT_REDIRECT_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_POST_LOGOUT_REDIRECT_URL, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_FORCE_AUTHN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_FORCE_AUTHN, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_SNOWFLAKE_ISSUER_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SNOWFLAKE_ISSUER_URL, 0) +} + +func (s *Create_security_integration_saml2Context) SAML2_SNOWFLAKE_ACS_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML2_SNOWFLAKE_ACS_URL, 0) +} + +func (s *Create_security_integration_saml2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_security_integration_saml2Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_security_integration_saml2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_security_integration_saml2(s) + } +} + +func (s *Create_security_integration_saml2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_security_integration_saml2(s) + } +} + +func (s *Create_security_integration_saml2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_security_integration_saml2(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_security_integration_saml2() (localctx ICreate_security_integration_saml2Context) { + localctx = NewCreate_security_integration_saml2Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, SnowflakeParserRULE_create_security_integration_saml2) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7746) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7747) + p.Or_replace() + } + + } + { + p.SetState(7750) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7751) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIF { + { + p.SetState(7752) + p.If_not_exists() + } + + } + { + p.SetState(7755) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7756) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7757) + p.Match(SnowflakeParserSAML2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7758) + p.Enabled_true_false() + } + { + p.SetState(7759) + p.Match(SnowflakeParserSAML2_ISSUER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7760) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7761) + p.String_() + } + { + p.SetState(7762) + p.Match(SnowflakeParserSAML2_SSO_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7763) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7764) + p.String_() + } + { + p.SetState(7765) + p.Match(SnowflakeParserSAML2_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7766) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7767) + p.String_() + } + { + p.SetState(7768) + p.Match(SnowflakeParserSAML2_X509_CERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7769) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7770) + p.String_() + } + p.SetState(7774) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SP_INITIATED_LOGIN_PAGE_LABEL { + { + p.SetState(7771) + p.Match(SnowflakeParserSAML2_SP_INITIATED_LOGIN_PAGE_LABEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7772) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7773) + p.String_() + } + + } + p.SetState(7779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_ENABLE_SP_INITIATED { + { + p.SetState(7776) + p.Match(SnowflakeParserSAML2_ENABLE_SP_INITIATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7777) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7778) + p.True_false() + } + + } + p.SetState(7784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SNOWFLAKE_X509_CERT { + { + p.SetState(7781) + p.Match(SnowflakeParserSAML2_SNOWFLAKE_X509_CERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7782) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7783) + p.String_() + } + + } + p.SetState(7789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SIGN_REQUEST { + { + p.SetState(7786) + p.Match(SnowflakeParserSAML2_SIGN_REQUEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7787) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7788) + p.True_false() + } + + } + p.SetState(7794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_REQUESTED_NAMEID_FORMAT { + { + p.SetState(7791) + p.Match(SnowflakeParserSAML2_REQUESTED_NAMEID_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7792) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7793) + p.String_() + } + + } + p.SetState(7799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_POST_LOGOUT_REDIRECT_URL { + { + p.SetState(7796) + p.Match(SnowflakeParserSAML2_POST_LOGOUT_REDIRECT_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7797) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7798) + p.String_() + } + + } + p.SetState(7804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_FORCE_AUTHN { + { + p.SetState(7801) + p.Match(SnowflakeParserSAML2_FORCE_AUTHN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7802) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7803) + p.True_false() + } + + } + p.SetState(7809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SNOWFLAKE_ISSUER_URL { + { + p.SetState(7806) + p.Match(SnowflakeParserSAML2_SNOWFLAKE_ISSUER_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7807) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7808) + p.String_() + } + + } + p.SetState(7814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSAML2_SNOWFLAKE_ACS_URL { + { + p.SetState(7811) + p.Match(SnowflakeParserSAML2_SNOWFLAKE_ACS_URL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7812) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7813) + p.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 +} + +// ICreate_security_integration_scimContext is an interface to support dynamic dispatch. +type ICreate_security_integration_scimContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + TYPE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + SCIM() antlr.TerminalNode + SCIM_CLIENT() antlr.TerminalNode + RUN_AS_ROLE() antlr.TerminalNode + OKTA_Q() antlr.TerminalNode + AZURE_Q() antlr.TerminalNode + GENERIC_Q() antlr.TerminalNode + OKTA_PROVISIONER_Q() antlr.TerminalNode + AAD_PROVISIONER_Q() antlr.TerminalNode + GENERIC_SCIM_PROVISIONER_Q() antlr.TerminalNode + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + Network_policy() INetwork_policyContext + SYNC_PASSWORD() antlr.TerminalNode + True_false() ITrue_falseContext + Comment_clause() IComment_clauseContext + + // IsCreate_security_integration_scimContext differentiates from other interfaces. + IsCreate_security_integration_scimContext() +} + +type Create_security_integration_scimContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_security_integration_scimContext() *Create_security_integration_scimContext { + var p = new(Create_security_integration_scimContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_security_integration_scim + return p +} + +func InitEmptyCreate_security_integration_scimContext(p *Create_security_integration_scimContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_security_integration_scim +} + +func (*Create_security_integration_scimContext) IsCreate_security_integration_scimContext() {} + +func NewCreate_security_integration_scimContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_security_integration_scimContext { + var p = new(Create_security_integration_scimContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_security_integration_scim + + return p +} + +func (s *Create_security_integration_scimContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_security_integration_scimContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_security_integration_scimContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Create_security_integration_scimContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Create_security_integration_scimContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_security_integration_scimContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_security_integration_scimContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_security_integration_scimContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_security_integration_scimContext) SCIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCIM, 0) +} + +func (s *Create_security_integration_scimContext) SCIM_CLIENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCIM_CLIENT, 0) +} + +func (s *Create_security_integration_scimContext) RUN_AS_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRUN_AS_ROLE, 0) +} + +func (s *Create_security_integration_scimContext) OKTA_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOKTA_Q, 0) +} + +func (s *Create_security_integration_scimContext) AZURE_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_Q, 0) +} + +func (s *Create_security_integration_scimContext) GENERIC_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGENERIC_Q, 0) +} + +func (s *Create_security_integration_scimContext) OKTA_PROVISIONER_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOKTA_PROVISIONER_Q, 0) +} + +func (s *Create_security_integration_scimContext) AAD_PROVISIONER_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAAD_PROVISIONER_Q, 0) +} + +func (s *Create_security_integration_scimContext) GENERIC_SCIM_PROVISIONER_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, 0) +} + +func (s *Create_security_integration_scimContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_security_integration_scimContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_security_integration_scimContext) Network_policy() INetwork_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INetwork_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INetwork_policyContext) +} + +func (s *Create_security_integration_scimContext) SYNC_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYNC_PASSWORD, 0) +} + +func (s *Create_security_integration_scimContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_security_integration_scimContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_security_integration_scimContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_security_integration_scimContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_security_integration_scimContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_security_integration_scim(s) + } +} + +func (s *Create_security_integration_scimContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_security_integration_scim(s) + } +} + +func (s *Create_security_integration_scimContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_security_integration_scim(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_security_integration_scim() (localctx ICreate_security_integration_scimContext) { + localctx = NewCreate_security_integration_scimContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, SnowflakeParserRULE_create_security_integration_scim) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7816) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7817) + p.Or_replace() + } + + } + { + p.SetState(7820) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7821) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7823) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 941, p.GetParserRuleContext()) == 1 { + { + p.SetState(7822) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7825) + p.Id_() + } + { + p.SetState(7826) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7827) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7828) + p.Match(SnowflakeParserSCIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7829) + p.Match(SnowflakeParserSCIM_CLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7830) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7831) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAZURE_Q || _la == SnowflakeParserGENERIC_Q || _la == SnowflakeParserOKTA_Q) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7832) + p.Match(SnowflakeParserRUN_AS_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7833) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7834) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAAD_PROVISIONER_Q || _la == SnowflakeParserGENERIC_SCIM_PROVISIONER_Q || _la == SnowflakeParserOKTA_PROVISIONER_Q) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(7836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNETWORK_POLICY { + { + p.SetState(7835) + p.Network_policy() + } + + } + p.SetState(7841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSYNC_PASSWORD { + { + p.SetState(7838) + p.Match(SnowflakeParserSYNC_PASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7839) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7840) + p.True_false() + } + + } + p.SetState(7844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7843) + p.Comment_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 +} + +// INetwork_policyContext is an interface to support dynamic dispatch. +type INetwork_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NETWORK_POLICY() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsNetwork_policyContext differentiates from other interfaces. + IsNetwork_policyContext() +} + +type Network_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNetwork_policyContext() *Network_policyContext { + var p = new(Network_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_network_policy + return p +} + +func InitEmptyNetwork_policyContext(p *Network_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_network_policy +} + +func (*Network_policyContext) IsNetwork_policyContext() {} + +func NewNetwork_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_policyContext { + var p = new(Network_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_network_policy + + return p +} + +func (s *Network_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Network_policyContext) NETWORK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK_POLICY, 0) +} + +func (s *Network_policyContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Network_policyContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Network_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Network_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Network_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterNetwork_policy(s) + } +} + +func (s *Network_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitNetwork_policy(s) + } +} + +func (s *Network_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitNetwork_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Network_policy() (localctx INetwork_policyContext) { + localctx = NewNetwork_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, SnowflakeParserRULE_network_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7846) + p.Match(SnowflakeParserNETWORK_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7847) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7848) + p.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 +} + +// IPartner_applicationContext is an interface to support dynamic dispatch. +type IPartner_applicationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLEAU_DESKTOP() antlr.TerminalNode + TABLEAU_SERVER() antlr.TerminalNode + LOOKER() antlr.TerminalNode + + // IsPartner_applicationContext differentiates from other interfaces. + IsPartner_applicationContext() +} + +type Partner_applicationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartner_applicationContext() *Partner_applicationContext { + var p = new(Partner_applicationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_partner_application + return p +} + +func InitEmptyPartner_applicationContext(p *Partner_applicationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_partner_application +} + +func (*Partner_applicationContext) IsPartner_applicationContext() {} + +func NewPartner_applicationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partner_applicationContext { + var p = new(Partner_applicationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_partner_application + + return p +} + +func (s *Partner_applicationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partner_applicationContext) TABLEAU_DESKTOP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLEAU_DESKTOP, 0) +} + +func (s *Partner_applicationContext) TABLEAU_SERVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLEAU_SERVER, 0) +} + +func (s *Partner_applicationContext) LOOKER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOOKER, 0) +} + +func (s *Partner_applicationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partner_applicationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partner_applicationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPartner_application(s) + } +} + +func (s *Partner_applicationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPartner_application(s) + } +} + +func (s *Partner_applicationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPartner_application(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Partner_application() (localctx IPartner_applicationContext) { + localctx = NewPartner_applicationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, SnowflakeParserRULE_partner_application) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7850) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserLOOKER || _la == SnowflakeParserTABLEAU_DESKTOP || _la == SnowflakeParserTABLEAU_SERVER) { + 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 +} + +// IStart_withContext is an interface to support dynamic dispatch. +type IStart_withContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + Num() INumContext + WITH() antlr.TerminalNode + EQ() antlr.TerminalNode + + // IsStart_withContext differentiates from other interfaces. + IsStart_withContext() +} + +type Start_withContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStart_withContext() *Start_withContext { + var p = new(Start_withContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_start_with + return p +} + +func InitEmptyStart_withContext(p *Start_withContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_start_with +} + +func (*Start_withContext) IsStart_withContext() {} + +func NewStart_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_withContext { + var p = new(Start_withContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_start_with + + return p +} + +func (s *Start_withContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_withContext) START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTART, 0) +} + +func (s *Start_withContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Start_withContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Start_withContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Start_withContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_withContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterStart_with(s) + } +} + +func (s *Start_withContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitStart_with(s) + } +} + +func (s *Start_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitStart_with(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Start_with() (localctx IStart_withContext) { + localctx = NewStart_withContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, SnowflakeParserRULE_start_with) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7852) + p.Match(SnowflakeParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(7853) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEQ { + { + p.SetState(7856) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7859) + p.Num() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIncrement_byContext is an interface to support dynamic dispatch. +type IIncrement_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCREMENT() antlr.TerminalNode + Num() INumContext + BY() antlr.TerminalNode + EQ() antlr.TerminalNode + + // IsIncrement_byContext differentiates from other interfaces. + IsIncrement_byContext() +} + +type Increment_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIncrement_byContext() *Increment_byContext { + var p = new(Increment_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_increment_by + return p +} + +func InitEmptyIncrement_byContext(p *Increment_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_increment_by +} + +func (*Increment_byContext) IsIncrement_byContext() {} + +func NewIncrement_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Increment_byContext { + var p = new(Increment_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_increment_by + + return p +} + +func (s *Increment_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Increment_byContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINCREMENT, 0) +} + +func (s *Increment_byContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Increment_byContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Increment_byContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Increment_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Increment_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Increment_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIncrement_by(s) + } +} + +func (s *Increment_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIncrement_by(s) + } +} + +func (s *Increment_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIncrement_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Increment_by() (localctx IIncrement_byContext) { + localctx = NewIncrement_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, SnowflakeParserRULE_increment_by) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7861) + p.Match(SnowflakeParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserBY { + { + p.SetState(7862) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEQ { + { + p.SetState(7865) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7868) + p.Num() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_sequenceContext is an interface to support dynamic dispatch. +type ICreate_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + Object_name() IObject_nameContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + WITH() antlr.TerminalNode + Start_with() IStart_withContext + Increment_by() IIncrement_byContext + Comment_clause() IComment_clauseContext + + // IsCreate_sequenceContext differentiates from other interfaces. + IsCreate_sequenceContext() +} + +type Create_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_sequenceContext() *Create_sequenceContext { + var p = new(Create_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_sequence + return p +} + +func InitEmptyCreate_sequenceContext(p *Create_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_sequence +} + +func (*Create_sequenceContext) IsCreate_sequenceContext() {} + +func NewCreate_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_sequenceContext { + var p = new(Create_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_sequence + + return p +} + +func (s *Create_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_sequenceContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 0) +} + +func (s *Create_sequenceContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_sequenceContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_sequenceContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_sequenceContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Create_sequenceContext) Start_with() IStart_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_withContext) +} + +func (s *Create_sequenceContext) Increment_by() IIncrement_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIncrement_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIncrement_byContext) +} + +func (s *Create_sequenceContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_sequence(s) + } +} + +func (s *Create_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_sequence(s) + } +} + +func (s *Create_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_sequence() (localctx ICreate_sequenceContext) { + localctx = NewCreate_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, SnowflakeParserRULE_create_sequence) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7870) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7871) + p.Or_replace() + } + + } + { + p.SetState(7874) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7876) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 950, p.GetParserRuleContext()) == 1 { + { + p.SetState(7875) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7878) + p.Object_name() + } + p.SetState(7880) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(7879) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTART { + { + p.SetState(7882) + p.Start_with() + } + + } + p.SetState(7886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserINCREMENT { + { + p.SetState(7885) + p.Increment_by() + } + + } + p.SetState(7889) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7888) + p.Comment_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 +} + +// ICreate_session_policyContext is an interface to support dynamic dispatch. +type ICreate_session_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SESSION() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + Or_replace() IOr_replaceContext + If_exists() IIf_existsContext + SESSION_IDLE_TIMEOUT_MINS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + SESSION_UI_IDLE_TIMEOUT_MINS() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsCreate_session_policyContext differentiates from other interfaces. + IsCreate_session_policyContext() +} + +type Create_session_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_session_policyContext() *Create_session_policyContext { + var p = new(Create_session_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_session_policy + return p +} + +func InitEmptyCreate_session_policyContext(p *Create_session_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_session_policy +} + +func (*Create_session_policyContext) IsCreate_session_policyContext() {} + +func NewCreate_session_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_session_policyContext { + var p = new(Create_session_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_session_policy + + return p +} + +func (s *Create_session_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_session_policyContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_session_policyContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Create_session_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Create_session_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_session_policyContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_session_policyContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Create_session_policyContext) SESSION_IDLE_TIMEOUT_MINS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, 0) +} + +func (s *Create_session_policyContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_session_policyContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_session_policyContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Create_session_policyContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Create_session_policyContext) SESSION_UI_IDLE_TIMEOUT_MINS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, 0) +} + +func (s *Create_session_policyContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_session_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_session_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_session_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_session_policy(s) + } +} + +func (s *Create_session_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_session_policy(s) + } +} + +func (s *Create_session_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_session_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_session_policy() (localctx ICreate_session_policyContext) { + localctx = NewCreate_session_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, SnowflakeParserRULE_create_session_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7891) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7892) + p.Or_replace() + } + + } + { + p.SetState(7895) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7896) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7898) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 956, p.GetParserRuleContext()) == 1 { + { + p.SetState(7897) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7900) + p.Id_() + } + p.SetState(7904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSESSION_IDLE_TIMEOUT_MINS { + { + p.SetState(7901) + p.Match(SnowflakeParserSESSION_IDLE_TIMEOUT_MINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7902) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7903) + p.Num() + } + + } + p.SetState(7909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS { + { + p.SetState(7906) + p.Match(SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7907) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7908) + p.Num() + } + + } + p.SetState(7912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7911) + p.Comment_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 +} + +// ICreate_shareContext is an interface to support dynamic dispatch. +type ICreate_shareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SHARE() antlr.TerminalNode + Id_() IId_Context + Or_replace() IOr_replaceContext + Comment_clause() IComment_clauseContext + + // IsCreate_shareContext differentiates from other interfaces. + IsCreate_shareContext() +} + +type Create_shareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_shareContext() *Create_shareContext { + var p = new(Create_shareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_share + return p +} + +func InitEmptyCreate_shareContext(p *Create_shareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_share +} + +func (*Create_shareContext) IsCreate_shareContext() {} + +func NewCreate_shareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_shareContext { + var p = new(Create_shareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_share + + return p +} + +func (s *Create_shareContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_shareContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_shareContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Create_shareContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_shareContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_shareContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_shareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_shareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_shareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_share(s) + } +} + +func (s *Create_shareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_share(s) + } +} + +func (s *Create_shareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_share(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_share() (localctx ICreate_shareContext) { + localctx = NewCreate_shareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, SnowflakeParserRULE_create_share) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7914) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(7915) + p.Or_replace() + } + + } + { + p.SetState(7918) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7919) + p.Id_() + } + p.SetState(7921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(7920) + p.Comment_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 +} + +// ICharacterContext is an interface to support dynamic dispatch. +type ICharacterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_LITERAL() 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 = SnowflakeParserRULE_character + return p +} + +func InitEmptyCharacterContext(p *CharacterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_character + + return p +} + +func (s *CharacterContext) GetParser() antlr.Parser { return s.parser } + +func (s *CharacterContext) CHAR_LITERAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHAR_LITERAL, 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.(SnowflakeParserListener); ok { + listenerT.EnterCharacter(s) + } +} + +func (s *CharacterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCharacter(s) + } +} + +func (s *CharacterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCharacter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Character() (localctx ICharacterContext) { + localctx = NewCharacterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, SnowflakeParserRULE_character) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7923) + p.Match(SnowflakeParserCHAR_LITERAL) + 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 +} + +// IFormat_type_optionsContext is an interface to support dynamic dispatch. +type IFormat_type_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPRESSION() antlr.TerminalNode + EQ() antlr.TerminalNode + AUTO() antlr.TerminalNode + GZIP() antlr.TerminalNode + BZ2() antlr.TerminalNode + BROTLI() antlr.TerminalNode + ZSTD() antlr.TerminalNode + DEFLATE() antlr.TerminalNode + RAW_DEFLATE() antlr.TerminalNode + NONE() antlr.TerminalNode + AUTO_Q() antlr.TerminalNode + RECORD_DELIMITER() antlr.TerminalNode + String_() IStringContext + FIELD_DELIMITER() antlr.TerminalNode + FILE_EXTENSION() antlr.TerminalNode + SKIP_HEADER() antlr.TerminalNode + Num() INumContext + SKIP_BLANK_LINES() antlr.TerminalNode + True_false() ITrue_falseContext + DATE_FORMAT() antlr.TerminalNode + TIME_FORMAT() antlr.TerminalNode + TIMESTAMP_FORMAT() antlr.TerminalNode + BINARY_FORMAT() antlr.TerminalNode + HEX() antlr.TerminalNode + BASE64() antlr.TerminalNode + UTF8() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + Character() ICharacterContext + NONE_Q() antlr.TerminalNode + ESCAPE_UNENCLOSED_FIELD() antlr.TerminalNode + TRIM_SPACE() antlr.TerminalNode + FIELD_OPTIONALLY_ENCLOSED_BY() antlr.TerminalNode + NULL_IF() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + String_list() IString_listContext + RR_BRACKET() antlr.TerminalNode + ERROR_ON_COLUMN_COUNT_MISMATCH() antlr.TerminalNode + REPLACE_INVALID_CHARACTERS() antlr.TerminalNode + EMPTY_FIELD_AS_NULL() antlr.TerminalNode + SKIP_BYTE_ORDER_MARK() antlr.TerminalNode + ENCODING() antlr.TerminalNode + ENABLE_OCTAL() antlr.TerminalNode + ALLOW_DUPLICATE() antlr.TerminalNode + STRIP_OUTER_ARRAY() antlr.TerminalNode + STRIP_NULL_VALUES() antlr.TerminalNode + IGNORE_UTF8_ERRORS() antlr.TerminalNode + LZO() antlr.TerminalNode + SNAPPY() antlr.TerminalNode + SNAPPY_COMPRESSION() antlr.TerminalNode + BINARY_AS_TEXT() antlr.TerminalNode + PRESERVE_SPACE() antlr.TerminalNode + STRIP_OUTER_ELEMENT() antlr.TerminalNode + DISABLE_SNOWFLAKE_DATA() antlr.TerminalNode + DISABLE_AUTO_CONVERT() antlr.TerminalNode + + // IsFormat_type_optionsContext differentiates from other interfaces. + IsFormat_type_optionsContext() +} + +type Format_type_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFormat_type_optionsContext() *Format_type_optionsContext { + var p = new(Format_type_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_format_type_options + return p +} + +func InitEmptyFormat_type_optionsContext(p *Format_type_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_format_type_options +} + +func (*Format_type_optionsContext) IsFormat_type_optionsContext() {} + +func NewFormat_type_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Format_type_optionsContext { + var p = new(Format_type_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_format_type_options + + return p +} + +func (s *Format_type_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Format_type_optionsContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMPRESSION, 0) +} + +func (s *Format_type_optionsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Format_type_optionsContext) AUTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO, 0) +} + +func (s *Format_type_optionsContext) GZIP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGZIP, 0) +} + +func (s *Format_type_optionsContext) BZ2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBZ2, 0) +} + +func (s *Format_type_optionsContext) BROTLI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBROTLI, 0) +} + +func (s *Format_type_optionsContext) ZSTD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserZSTD, 0) +} + +func (s *Format_type_optionsContext) DEFLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFLATE, 0) +} + +func (s *Format_type_optionsContext) RAW_DEFLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRAW_DEFLATE, 0) +} + +func (s *Format_type_optionsContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *Format_type_optionsContext) AUTO_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_Q, 0) +} + +func (s *Format_type_optionsContext) RECORD_DELIMITER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECORD_DELIMITER, 0) +} + +func (s *Format_type_optionsContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Format_type_optionsContext) FIELD_DELIMITER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIELD_DELIMITER, 0) +} + +func (s *Format_type_optionsContext) FILE_EXTENSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE_EXTENSION, 0) +} + +func (s *Format_type_optionsContext) SKIP_HEADER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_HEADER, 0) +} + +func (s *Format_type_optionsContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Format_type_optionsContext) SKIP_BLANK_LINES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_BLANK_LINES, 0) +} + +func (s *Format_type_optionsContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Format_type_optionsContext) DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_FORMAT, 0) +} + +func (s *Format_type_optionsContext) TIME_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME_FORMAT, 0) +} + +func (s *Format_type_optionsContext) TIMESTAMP_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_FORMAT, 0) +} + +func (s *Format_type_optionsContext) BINARY_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_FORMAT, 0) +} + +func (s *Format_type_optionsContext) HEX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHEX, 0) +} + +func (s *Format_type_optionsContext) BASE64() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBASE64, 0) +} + +func (s *Format_type_optionsContext) UTF8() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUTF8, 0) +} + +func (s *Format_type_optionsContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserESCAPE, 0) +} + +func (s *Format_type_optionsContext) 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 *Format_type_optionsContext) NONE_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE_Q, 0) +} + +func (s *Format_type_optionsContext) ESCAPE_UNENCLOSED_FIELD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserESCAPE_UNENCLOSED_FIELD, 0) +} + +func (s *Format_type_optionsContext) TRIM_SPACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRIM_SPACE, 0) +} + +func (s *Format_type_optionsContext) FIELD_OPTIONALLY_ENCLOSED_BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, 0) +} + +func (s *Format_type_optionsContext) NULL_IF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_IF, 0) +} + +func (s *Format_type_optionsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Format_type_optionsContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Format_type_optionsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Format_type_optionsContext) ERROR_ON_COLUMN_COUNT_MISMATCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, 0) +} + +func (s *Format_type_optionsContext) REPLACE_INVALID_CHARACTERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLACE_INVALID_CHARACTERS, 0) +} + +func (s *Format_type_optionsContext) EMPTY_FIELD_AS_NULL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEMPTY_FIELD_AS_NULL, 0) +} + +func (s *Format_type_optionsContext) SKIP_BYTE_ORDER_MARK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_BYTE_ORDER_MARK, 0) +} + +func (s *Format_type_optionsContext) ENCODING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENCODING, 0) +} + +func (s *Format_type_optionsContext) ENABLE_OCTAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_OCTAL, 0) +} + +func (s *Format_type_optionsContext) ALLOW_DUPLICATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_DUPLICATE, 0) +} + +func (s *Format_type_optionsContext) STRIP_OUTER_ARRAY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRIP_OUTER_ARRAY, 0) +} + +func (s *Format_type_optionsContext) STRIP_NULL_VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRIP_NULL_VALUES, 0) +} + +func (s *Format_type_optionsContext) IGNORE_UTF8_ERRORS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE_UTF8_ERRORS, 0) +} + +func (s *Format_type_optionsContext) LZO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLZO, 0) +} + +func (s *Format_type_optionsContext) SNAPPY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSNAPPY, 0) +} + +func (s *Format_type_optionsContext) SNAPPY_COMPRESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSNAPPY_COMPRESSION, 0) +} + +func (s *Format_type_optionsContext) BINARY_AS_TEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_AS_TEXT, 0) +} + +func (s *Format_type_optionsContext) PRESERVE_SPACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRESERVE_SPACE, 0) +} + +func (s *Format_type_optionsContext) STRIP_OUTER_ELEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRIP_OUTER_ELEMENT, 0) +} + +func (s *Format_type_optionsContext) DISABLE_SNOWFLAKE_DATA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE_SNOWFLAKE_DATA, 0) +} + +func (s *Format_type_optionsContext) DISABLE_AUTO_CONVERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE_AUTO_CONVERT, 0) +} + +func (s *Format_type_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Format_type_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Format_type_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFormat_type_options(s) + } +} + +func (s *Format_type_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFormat_type_options(s) + } +} + +func (s *Format_type_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFormat_type_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Format_type_options() (localctx IFormat_type_optionsContext) { + localctx = NewFormat_type_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, SnowflakeParserRULE_format_type_options) + var _la int + + p.SetState(8067) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 971, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7925) + p.Match(SnowflakeParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7926) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7927) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-62)) & ^0x3f) == 0 && ((int64(1)<<(_la-62))&633318697598979) != 0) || _la == SnowflakeParserDEFLATE || _la == SnowflakeParserGZIP || _la == SnowflakeParserNONE || _la == SnowflakeParserRAW_DEFLATE || _la == SnowflakeParserZSTD) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7928) + p.Match(SnowflakeParserRECORD_DELIMITER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7929) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7930) + p.String_() + } + + case SnowflakeParserNONE: + { + p.SetState(7931) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7934) + p.Match(SnowflakeParserFIELD_DELIMITER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7935) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7936) + p.String_() + } + + case SnowflakeParserNONE: + { + p.SetState(7937) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7940) + p.Match(SnowflakeParserFILE_EXTENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7941) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7942) + p.String_() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7943) + p.Match(SnowflakeParserSKIP_HEADER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7944) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7945) + p.Num() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7946) + p.Match(SnowflakeParserSKIP_BLANK_LINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7947) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7948) + p.True_false() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7949) + p.Match(SnowflakeParserDATE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7950) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7951) + p.String_() + } + + case SnowflakeParserAUTO: + { + p.SetState(7952) + p.Match(SnowflakeParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7955) + p.Match(SnowflakeParserTIME_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7956) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7959) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7957) + p.String_() + } + + case SnowflakeParserAUTO: + { + p.SetState(7958) + p.Match(SnowflakeParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7961) + p.Match(SnowflakeParserTIMESTAMP_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7962) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7963) + p.String_() + } + + case SnowflakeParserAUTO: + { + p.SetState(7964) + p.Match(SnowflakeParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(7967) + p.Match(SnowflakeParserBINARY_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7968) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7969) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserBASE64 || _la == SnowflakeParserHEX || _la == SnowflakeParserUTF8) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(7970) + p.Match(SnowflakeParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7971) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCHAR_LITERAL: + { + p.SetState(7972) + p.Character() + } + + case SnowflakeParserNONE: + { + p.SetState(7973) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNONE_Q: + { + p.SetState(7974) + p.Match(SnowflakeParserNONE_Q) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(7977) + p.Match(SnowflakeParserESCAPE_UNENCLOSED_FIELD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7978) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7979) + p.String_() + } + + case SnowflakeParserNONE: + { + p.SetState(7980) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNONE_Q: + { + p.SetState(7981) + p.Match(SnowflakeParserNONE_Q) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(7984) + p.Match(SnowflakeParserTRIM_SPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7985) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7986) + p.True_false() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(7987) + p.Match(SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7988) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(7989) + p.String_() + } + + case SnowflakeParserNONE: + { + p.SetState(7990) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNONE_Q: + { + p.SetState(7991) + p.Match(SnowflakeParserNONE_Q) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(7994) + p.Match(SnowflakeParserNULL_IF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7995) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7996) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7997) + p.String_list() + } + { + p.SetState(7998) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(8000) + p.Match(SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8001) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8002) + p.True_false() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(8003) + p.Match(SnowflakeParserREPLACE_INVALID_CHARACTERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8004) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8005) + p.True_false() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(8006) + p.Match(SnowflakeParserEMPTY_FIELD_AS_NULL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8007) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8008) + p.True_false() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(8009) + p.Match(SnowflakeParserSKIP_BYTE_ORDER_MARK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8010) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8011) + p.True_false() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(8012) + p.Match(SnowflakeParserENCODING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8013) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(8014) + p.String_() + } + + case SnowflakeParserUTF8: + { + p.SetState(8015) + p.Match(SnowflakeParserUTF8) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(8018) + p.Match(SnowflakeParserENABLE_OCTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8019) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8020) + p.True_false() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(8021) + p.Match(SnowflakeParserALLOW_DUPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8022) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8023) + p.True_false() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(8024) + p.Match(SnowflakeParserSTRIP_OUTER_ARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8025) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8026) + p.True_false() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(8027) + p.Match(SnowflakeParserSTRIP_NULL_VALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8028) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8029) + p.True_false() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(8030) + p.Match(SnowflakeParserIGNORE_UTF8_ERRORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8031) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8032) + p.True_false() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(8033) + p.Match(SnowflakeParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8034) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8035) + p.Match(SnowflakeParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(8036) + p.Match(SnowflakeParserLZO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(8037) + p.Match(SnowflakeParserSNAPPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(8038) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(8039) + p.Match(SnowflakeParserSNAPPY_COMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8040) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8041) + p.True_false() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(8042) + p.Match(SnowflakeParserBINARY_AS_TEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8043) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8044) + p.True_false() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(8045) + p.Match(SnowflakeParserCOMPRESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8046) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8047) + p.Match(SnowflakeParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(8048) + p.Match(SnowflakeParserGZIP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(8049) + p.Match(SnowflakeParserBZ2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(8050) + p.Match(SnowflakeParserBROTLI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(8051) + p.Match(SnowflakeParserZSTD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(8052) + p.Match(SnowflakeParserDEFLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(8053) + p.Match(SnowflakeParserRAW_DEFLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(8054) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(8055) + p.Match(SnowflakeParserPRESERVE_SPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8056) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8057) + p.True_false() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(8058) + p.Match(SnowflakeParserSTRIP_OUTER_ELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8059) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8060) + p.True_false() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(8061) + p.Match(SnowflakeParserDISABLE_SNOWFLAKE_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8062) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8063) + p.True_false() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(8064) + p.Match(SnowflakeParserDISABLE_AUTO_CONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8065) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8066) + p.True_false() + } + + 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_optionsContext is an interface to support dynamic dispatch. +type ICopy_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON_ERROR() antlr.TerminalNode + EQ() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + SKIP_FILE() antlr.TerminalNode + SKIP_FILE_N() antlr.TerminalNode + ABORT_STATEMENT() antlr.TerminalNode + SIZE_LIMIT() antlr.TerminalNode + Num() INumContext + PURGE() antlr.TerminalNode + True_false() ITrue_falseContext + RETURN_FAILED_ONLY() antlr.TerminalNode + MATCH_BY_COLUMN_NAME() antlr.TerminalNode + CASE_SENSITIVE() antlr.TerminalNode + CASE_INSENSITIVE() antlr.TerminalNode + NONE() antlr.TerminalNode + ENFORCE_LENGTH() antlr.TerminalNode + TRUNCATECOLUMNS() antlr.TerminalNode + FORCE() 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 = SnowflakeParserRULE_copy_options + return p +} + +func InitEmptyCopy_optionsContext(p *Copy_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_copy_options + + return p +} + +func (s *Copy_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_optionsContext) ON_ERROR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON_ERROR, 0) +} + +func (s *Copy_optionsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Copy_optionsContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTINUE, 0) +} + +func (s *Copy_optionsContext) SKIP_FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_FILE, 0) +} + +func (s *Copy_optionsContext) SKIP_FILE_N() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_FILE_N, 0) +} + +func (s *Copy_optionsContext) ABORT_STATEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT_STATEMENT, 0) +} + +func (s *Copy_optionsContext) SIZE_LIMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIZE_LIMIT, 0) +} + +func (s *Copy_optionsContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Copy_optionsContext) PURGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPURGE, 0) +} + +func (s *Copy_optionsContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Copy_optionsContext) RETURN_FAILED_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_FAILED_ONLY, 0) +} + +func (s *Copy_optionsContext) MATCH_BY_COLUMN_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCH_BY_COLUMN_NAME, 0) +} + +func (s *Copy_optionsContext) CASE_SENSITIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCASE_SENSITIVE, 0) +} + +func (s *Copy_optionsContext) CASE_INSENSITIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCASE_INSENSITIVE, 0) +} + +func (s *Copy_optionsContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *Copy_optionsContext) ENFORCE_LENGTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENFORCE_LENGTH, 0) +} + +func (s *Copy_optionsContext) TRUNCATECOLUMNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUNCATECOLUMNS, 0) +} + +func (s *Copy_optionsContext) FORCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORCE, 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.(SnowflakeParserListener); ok { + listenerT.EnterCopy_options(s) + } +} + +func (s *Copy_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCopy_options(s) + } +} + +func (s *Copy_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCopy_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Copy_options() (localctx ICopy_optionsContext) { + localctx = NewCopy_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, SnowflakeParserRULE_copy_options) + p.SetState(8101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserON_ERROR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8069) + p.Match(SnowflakeParserON_ERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8070) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 972, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8071) + p.Match(SnowflakeParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(8072) + p.Match(SnowflakeParserSKIP_FILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(8073) + p.Match(SnowflakeParserSKIP_FILE_N) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(8074) + p.Match(SnowflakeParserSKIP_FILE_N) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8075) + p.Match(SnowflakeParserABORT_STATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case SnowflakeParserSIZE_LIMIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8078) + p.Match(SnowflakeParserSIZE_LIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8079) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8080) + p.Num() + } + + case SnowflakeParserPURGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8081) + p.Match(SnowflakeParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8082) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8083) + p.True_false() + } + + case SnowflakeParserRETURN_FAILED_ONLY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8084) + p.Match(SnowflakeParserRETURN_FAILED_ONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8085) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8086) + p.True_false() + } + + case SnowflakeParserMATCH_BY_COLUMN_NAME: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(8087) + p.Match(SnowflakeParserMATCH_BY_COLUMN_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8088) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8089) + p.Match(SnowflakeParserCASE_SENSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserCASE_INSENSITIVE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(8090) + p.Match(SnowflakeParserCASE_INSENSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNONE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(8091) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserENFORCE_LENGTH: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(8092) + p.Match(SnowflakeParserENFORCE_LENGTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8093) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8094) + p.True_false() + } + + case SnowflakeParserTRUNCATECOLUMNS: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(8095) + p.Match(SnowflakeParserTRUNCATECOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8096) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8097) + p.True_false() + } + + case SnowflakeParserFORCE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(8098) + p.Match(SnowflakeParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8099) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8100) + p.True_false() + } + + 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 +} + +// IInternal_stage_paramsContext is an interface to support dynamic dispatch. +type IInternal_stage_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + TYPE() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsInternal_stage_paramsContext differentiates from other interfaces. + IsInternal_stage_paramsContext() +} + +type Internal_stage_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInternal_stage_paramsContext() *Internal_stage_paramsContext { + var p = new(Internal_stage_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_internal_stage_params + return p +} + +func InitEmptyInternal_stage_paramsContext(p *Internal_stage_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_internal_stage_params +} + +func (*Internal_stage_paramsContext) IsInternal_stage_paramsContext() {} + +func NewInternal_stage_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Internal_stage_paramsContext { + var p = new(Internal_stage_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_internal_stage_params + + return p +} + +func (s *Internal_stage_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Internal_stage_paramsContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENCRYPTION, 0) +} + +func (s *Internal_stage_paramsContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Internal_stage_paramsContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Internal_stage_paramsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Internal_stage_paramsContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Internal_stage_paramsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Internal_stage_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Internal_stage_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Internal_stage_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterInternal_stage_params(s) + } +} + +func (s *Internal_stage_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitInternal_stage_params(s) + } +} + +func (s *Internal_stage_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitInternal_stage_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Internal_stage_params() (localctx IInternal_stage_paramsContext) { + localctx = NewInternal_stage_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, SnowflakeParserRULE_internal_stage_params) + p.SetState(8111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserENCRYPTION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8103) + p.Match(SnowflakeParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8104) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8105) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8106) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8107) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTYPE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8108) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8109) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8110) + p.Match(SnowflakeParserRR_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 +} + +// IStage_typeContext is an interface to support dynamic dispatch. +type IStage_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TYPE() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsStage_typeContext differentiates from other interfaces. + IsStage_typeContext() +} + +type Stage_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStage_typeContext() *Stage_typeContext { + var p = new(Stage_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_type + return p +} + +func InitEmptyStage_typeContext(p *Stage_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_type +} + +func (*Stage_typeContext) IsStage_typeContext() {} + +func NewStage_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stage_typeContext { + var p = new(Stage_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_stage_type + + return p +} + +func (s *Stage_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stage_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Stage_typeContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Stage_typeContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Stage_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stage_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stage_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterStage_type(s) + } +} + +func (s *Stage_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitStage_type(s) + } +} + +func (s *Stage_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitStage_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Stage_type() (localctx IStage_typeContext) { + localctx = NewStage_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, SnowflakeParserRULE_stage_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8113) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8114) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8115) + p.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 +} + +// IStage_master_keyContext is an interface to support dynamic dispatch. +type IStage_master_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MASTER_KEY() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsStage_master_keyContext differentiates from other interfaces. + IsStage_master_keyContext() +} + +type Stage_master_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStage_master_keyContext() *Stage_master_keyContext { + var p = new(Stage_master_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_master_key + return p +} + +func InitEmptyStage_master_keyContext(p *Stage_master_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_master_key +} + +func (*Stage_master_keyContext) IsStage_master_keyContext() {} + +func NewStage_master_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stage_master_keyContext { + var p = new(Stage_master_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_stage_master_key + + return p +} + +func (s *Stage_master_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stage_master_keyContext) MASTER_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASTER_KEY, 0) +} + +func (s *Stage_master_keyContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Stage_master_keyContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Stage_master_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stage_master_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stage_master_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterStage_master_key(s) + } +} + +func (s *Stage_master_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitStage_master_key(s) + } +} + +func (s *Stage_master_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitStage_master_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Stage_master_key() (localctx IStage_master_keyContext) { + localctx = NewStage_master_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, SnowflakeParserRULE_stage_master_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8117) + p.Match(SnowflakeParserMASTER_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8118) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8119) + p.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 +} + +// IStage_kms_keyContext is an interface to support dynamic dispatch. +type IStage_kms_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KMS_KEY_ID() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsStage_kms_keyContext differentiates from other interfaces. + IsStage_kms_keyContext() +} + +type Stage_kms_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStage_kms_keyContext() *Stage_kms_keyContext { + var p = new(Stage_kms_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_kms_key + return p +} + +func InitEmptyStage_kms_keyContext(p *Stage_kms_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_kms_key +} + +func (*Stage_kms_keyContext) IsStage_kms_keyContext() {} + +func NewStage_kms_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stage_kms_keyContext { + var p = new(Stage_kms_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_stage_kms_key + + return p +} + +func (s *Stage_kms_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stage_kms_keyContext) KMS_KEY_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKMS_KEY_ID, 0) +} + +func (s *Stage_kms_keyContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Stage_kms_keyContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Stage_kms_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stage_kms_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stage_kms_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterStage_kms_key(s) + } +} + +func (s *Stage_kms_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitStage_kms_key(s) + } +} + +func (s *Stage_kms_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitStage_kms_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Stage_kms_key() (localctx IStage_kms_keyContext) { + localctx = NewStage_kms_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, SnowflakeParserRULE_stage_kms_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8121) + p.Match(SnowflakeParserKMS_KEY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8122) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8123) + p.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 +} + +// IStage_encryption_opts_awsContext is an interface to support dynamic dispatch. +type IStage_encryption_opts_awsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + EQ() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Stage_master_key() IStage_master_keyContext + Stage_type() IStage_typeContext + Stage_kms_key() IStage_kms_keyContext + + // IsStage_encryption_opts_awsContext differentiates from other interfaces. + IsStage_encryption_opts_awsContext() +} + +type Stage_encryption_opts_awsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStage_encryption_opts_awsContext() *Stage_encryption_opts_awsContext { + var p = new(Stage_encryption_opts_awsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_encryption_opts_aws + return p +} + +func InitEmptyStage_encryption_opts_awsContext(p *Stage_encryption_opts_awsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stage_encryption_opts_aws +} + +func (*Stage_encryption_opts_awsContext) IsStage_encryption_opts_awsContext() {} + +func NewStage_encryption_opts_awsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stage_encryption_opts_awsContext { + var p = new(Stage_encryption_opts_awsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_stage_encryption_opts_aws + + return p +} + +func (s *Stage_encryption_opts_awsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stage_encryption_opts_awsContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENCRYPTION, 0) +} + +func (s *Stage_encryption_opts_awsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Stage_encryption_opts_awsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Stage_encryption_opts_awsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Stage_encryption_opts_awsContext) Stage_master_key() IStage_master_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStage_master_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStage_master_keyContext) +} + +func (s *Stage_encryption_opts_awsContext) Stage_type() IStage_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStage_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStage_typeContext) +} + +func (s *Stage_encryption_opts_awsContext) Stage_kms_key() IStage_kms_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStage_kms_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStage_kms_keyContext) +} + +func (s *Stage_encryption_opts_awsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stage_encryption_opts_awsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stage_encryption_opts_awsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterStage_encryption_opts_aws(s) + } +} + +func (s *Stage_encryption_opts_awsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitStage_encryption_opts_aws(s) + } +} + +func (s *Stage_encryption_opts_awsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitStage_encryption_opts_aws(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Stage_encryption_opts_aws() (localctx IStage_encryption_opts_awsContext) { + localctx = NewStage_encryption_opts_awsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, SnowflakeParserRULE_stage_encryption_opts_aws) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8125) + p.Match(SnowflakeParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8126) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8127) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 980, p.GetParserRuleContext()) { + case 1: + p.SetState(8129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(8128) + p.Stage_type() + } + + } + { + p.SetState(8131) + p.Stage_master_key() + } + + case 2: + p.SetState(8133) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(8132) + p.Stage_type() + } + + } + + case 3: + p.SetState(8139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(8135) + p.Stage_type() + } + p.SetState(8137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserKMS_KEY_ID { + { + p.SetState(8136) + p.Stage_kms_key() + } + + } + + } + + case 4: + p.SetState(8142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(8141) + p.Stage_type() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(8146) + p.Match(SnowflakeParserRR_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 +} + +// IAws_tokenContext is an interface to support dynamic dispatch. +type IAws_tokenContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AWS_TOKEN() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsAws_tokenContext differentiates from other interfaces. + IsAws_tokenContext() +} + +type Aws_tokenContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAws_tokenContext() *Aws_tokenContext { + var p = new(Aws_tokenContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aws_token + return p +} + +func InitEmptyAws_tokenContext(p *Aws_tokenContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aws_token +} + +func (*Aws_tokenContext) IsAws_tokenContext() {} + +func NewAws_tokenContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aws_tokenContext { + var p = new(Aws_tokenContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_aws_token + + return p +} + +func (s *Aws_tokenContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aws_tokenContext) AWS_TOKEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_TOKEN, 0) +} + +func (s *Aws_tokenContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Aws_tokenContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Aws_tokenContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aws_tokenContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aws_tokenContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAws_token(s) + } +} + +func (s *Aws_tokenContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAws_token(s) + } +} + +func (s *Aws_tokenContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAws_token(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Aws_token() (localctx IAws_tokenContext) { + localctx = NewAws_tokenContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, SnowflakeParserRULE_aws_token) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8148) + p.Match(SnowflakeParserAWS_TOKEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8149) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8150) + p.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 +} + +// IAws_key_idContext is an interface to support dynamic dispatch. +type IAws_key_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AWS_KEY_ID() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsAws_key_idContext differentiates from other interfaces. + IsAws_key_idContext() +} + +type Aws_key_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAws_key_idContext() *Aws_key_idContext { + var p = new(Aws_key_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aws_key_id + return p +} + +func InitEmptyAws_key_idContext(p *Aws_key_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aws_key_id +} + +func (*Aws_key_idContext) IsAws_key_idContext() {} + +func NewAws_key_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aws_key_idContext { + var p = new(Aws_key_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_aws_key_id + + return p +} + +func (s *Aws_key_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aws_key_idContext) AWS_KEY_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_KEY_ID, 0) +} + +func (s *Aws_key_idContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Aws_key_idContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Aws_key_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aws_key_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aws_key_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAws_key_id(s) + } +} + +func (s *Aws_key_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAws_key_id(s) + } +} + +func (s *Aws_key_idContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAws_key_id(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Aws_key_id() (localctx IAws_key_idContext) { + localctx = NewAws_key_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, SnowflakeParserRULE_aws_key_id) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8152) + p.Match(SnowflakeParserAWS_KEY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8153) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8154) + p.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 +} + +// IAws_secret_keyContext is an interface to support dynamic dispatch. +type IAws_secret_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AWS_SECRET_KEY() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsAws_secret_keyContext differentiates from other interfaces. + IsAws_secret_keyContext() +} + +type Aws_secret_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAws_secret_keyContext() *Aws_secret_keyContext { + var p = new(Aws_secret_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aws_secret_key + return p +} + +func InitEmptyAws_secret_keyContext(p *Aws_secret_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aws_secret_key +} + +func (*Aws_secret_keyContext) IsAws_secret_keyContext() {} + +func NewAws_secret_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aws_secret_keyContext { + var p = new(Aws_secret_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_aws_secret_key + + return p +} + +func (s *Aws_secret_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aws_secret_keyContext) AWS_SECRET_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SECRET_KEY, 0) +} + +func (s *Aws_secret_keyContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Aws_secret_keyContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Aws_secret_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aws_secret_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aws_secret_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAws_secret_key(s) + } +} + +func (s *Aws_secret_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAws_secret_key(s) + } +} + +func (s *Aws_secret_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAws_secret_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Aws_secret_key() (localctx IAws_secret_keyContext) { + localctx = NewAws_secret_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, SnowflakeParserRULE_aws_secret_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8156) + p.Match(SnowflakeParserAWS_SECRET_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8157) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8158) + p.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 +} + +// IAws_roleContext is an interface to support dynamic dispatch. +type IAws_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AWS_ROLE() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsAws_roleContext differentiates from other interfaces. + IsAws_roleContext() +} + +type Aws_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAws_roleContext() *Aws_roleContext { + var p = new(Aws_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aws_role + return p +} + +func InitEmptyAws_roleContext(p *Aws_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aws_role +} + +func (*Aws_roleContext) IsAws_roleContext() {} + +func NewAws_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aws_roleContext { + var p = new(Aws_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_aws_role + + return p +} + +func (s *Aws_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aws_roleContext) AWS_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_ROLE, 0) +} + +func (s *Aws_roleContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Aws_roleContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Aws_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aws_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aws_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAws_role(s) + } +} + +func (s *Aws_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAws_role(s) + } +} + +func (s *Aws_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAws_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Aws_role() (localctx IAws_roleContext) { + localctx = NewAws_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, SnowflakeParserRULE_aws_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8160) + p.Match(SnowflakeParserAWS_ROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8161) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8162) + p.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 +} + +// IExternal_stage_paramsContext is an interface to support dynamic dispatch. +type IExternal_stage_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + URL() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + String_list() IString_listContext + Stage_encryption_opts_aws() IStage_encryption_opts_awsContext + STORAGE_INTEGRATION() antlr.TerminalNode + Id_() IId_Context + CREDENTIALS() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Aws_role() IAws_roleContext + Aws_key_id() IAws_key_idContext + Aws_secret_key() IAws_secret_keyContext + Aws_token() IAws_tokenContext + AllString_() []IStringContext + String_(i int) IStringContext + ENCRYPTION() antlr.TerminalNode + TYPE() antlr.TerminalNode + KMS_KEY_ID() antlr.TerminalNode + NONE() antlr.TerminalNode + MASTER_KEY() antlr.TerminalNode + AZURE_SAS_TOKEN() antlr.TerminalNode + + // IsExternal_stage_paramsContext differentiates from other interfaces. + IsExternal_stage_paramsContext() +} + +type External_stage_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_stage_paramsContext() *External_stage_paramsContext { + var p = new(External_stage_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_stage_params + return p +} + +func InitEmptyExternal_stage_paramsContext(p *External_stage_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_external_stage_params +} + +func (*External_stage_paramsContext) IsExternal_stage_paramsContext() {} + +func NewExternal_stage_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_stage_paramsContext { + var p = new(External_stage_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_external_stage_params + + return p +} + +func (s *External_stage_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_stage_paramsContext) URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserURL, 0) +} + +func (s *External_stage_paramsContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *External_stage_paramsContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *External_stage_paramsContext) String_list() IString_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *External_stage_paramsContext) Stage_encryption_opts_aws() IStage_encryption_opts_awsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStage_encryption_opts_awsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStage_encryption_opts_awsContext) +} + +func (s *External_stage_paramsContext) STORAGE_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_INTEGRATION, 0) +} + +func (s *External_stage_paramsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *External_stage_paramsContext) CREDENTIALS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREDENTIALS, 0) +} + +func (s *External_stage_paramsContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *External_stage_paramsContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *External_stage_paramsContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *External_stage_paramsContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *External_stage_paramsContext) Aws_role() IAws_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAws_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAws_roleContext) +} + +func (s *External_stage_paramsContext) Aws_key_id() IAws_key_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAws_key_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAws_key_idContext) +} + +func (s *External_stage_paramsContext) Aws_secret_key() IAws_secret_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAws_secret_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAws_secret_keyContext) +} + +func (s *External_stage_paramsContext) Aws_token() IAws_tokenContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAws_tokenContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAws_tokenContext) +} + +func (s *External_stage_paramsContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *External_stage_paramsContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *External_stage_paramsContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENCRYPTION, 0) +} + +func (s *External_stage_paramsContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *External_stage_paramsContext) KMS_KEY_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKMS_KEY_ID, 0) +} + +func (s *External_stage_paramsContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *External_stage_paramsContext) MASTER_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASTER_KEY, 0) +} + +func (s *External_stage_paramsContext) AZURE_SAS_TOKEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_SAS_TOKEN, 0) +} + +func (s *External_stage_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_stage_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_stage_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExternal_stage_params(s) + } +} + +func (s *External_stage_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExternal_stage_params(s) + } +} + +func (s *External_stage_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExternal_stage_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) External_stage_params() (localctx IExternal_stage_paramsContext) { + localctx = NewExternal_stage_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, SnowflakeParserRULE_external_stage_params) + var _la int + + p.SetState(8253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 997, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8164) + p.Match(SnowflakeParserURL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8165) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8166) + p.String_list() + } + p.SetState(8183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTORAGE_INTEGRATION: + { + p.SetState(8167) + p.Match(SnowflakeParserSTORAGE_INTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8168) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8169) + p.Id_() + } + + case SnowflakeParserCREDENTIALS: + { + p.SetState(8170) + p.Match(SnowflakeParserCREDENTIALS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8171) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8172) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAWS_KEY_ID: + { + p.SetState(8173) + p.Aws_key_id() + } + { + p.SetState(8174) + p.Aws_secret_key() + } + p.SetState(8176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAWS_TOKEN { + { + p.SetState(8175) + p.Aws_token() + } + + } + + case SnowflakeParserAWS_ROLE: + { + p.SetState(8178) + p.Aws_role() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(8181) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserEOF, SnowflakeParserCOMMENT, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserDIRECTORY, SnowflakeParserENCRYPTION, SnowflakeParserFILE_FORMAT, SnowflakeParserTAG, SnowflakeParserWITH, SnowflakeParserSEMI: + + default: + } + p.SetState(8186) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENCRYPTION { + { + p.SetState(8185) + p.Stage_encryption_opts_aws() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8188) + p.Match(SnowflakeParserURL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8189) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8190) + p.String_() + } + p.SetState(8194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE_INTEGRATION { + { + p.SetState(8191) + p.Match(SnowflakeParserSTORAGE_INTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8192) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8193) + p.Id_() + } + + } + p.SetState(8214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENCRYPTION { + { + p.SetState(8196) + p.Match(SnowflakeParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8197) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 989, p.GetParserRuleContext()) { + case 1: + p.SetState(8200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(8198) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8199) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserKMS_KEY_ID { + { + p.SetState(8202) + p.Match(SnowflakeParserKMS_KEY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8203) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8204) + p.String_() + } + + } + + case 2: + p.SetState(8210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(8207) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8208) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8209) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8216) + p.Match(SnowflakeParserURL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8217) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8218) + p.String_() + } + p.SetState(8231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTORAGE_INTEGRATION: + { + p.SetState(8219) + p.Match(SnowflakeParserSTORAGE_INTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8220) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8221) + p.Id_() + } + + case SnowflakeParserCREDENTIALS: + { + p.SetState(8222) + p.Match(SnowflakeParserCREDENTIALS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8223) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8224) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAZURE_SAS_TOKEN { + { + p.SetState(8225) + p.Match(SnowflakeParserAZURE_SAS_TOKEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8226) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8227) + p.String_() + } + + } + { + p.SetState(8230) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserEOF, SnowflakeParserCOMMENT, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserDIRECTORY, SnowflakeParserENCRYPTION, SnowflakeParserFILE_FORMAT, SnowflakeParserTAG, SnowflakeParserTYPE, SnowflakeParserWITH, SnowflakeParserRR_BRACKET, SnowflakeParserSEMI: + + default: + } + p.SetState(8251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case SnowflakeParserENCRYPTION: + { + p.SetState(8233) + p.Match(SnowflakeParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8234) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8235) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(8236) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8237) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMASTER_KEY { + { + p.SetState(8240) + p.Match(SnowflakeParserMASTER_KEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8241) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8242) + p.String_() + } + + } + + case SnowflakeParserTYPE, SnowflakeParserRR_BRACKET: + p.SetState(8248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(8245) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8246) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8247) + p.Match(SnowflakeParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8250) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserEOF, SnowflakeParserCOMMENT, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserDIRECTORY, SnowflakeParserFILE_FORMAT, SnowflakeParserTAG, SnowflakeParserWITH, SnowflakeParserSEMI: + + default: + } + + 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 +} + +// ITrue_falseContext is an interface to support dynamic dispatch. +type ITrue_falseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + + // IsTrue_falseContext differentiates from other interfaces. + IsTrue_falseContext() +} + +type True_falseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrue_falseContext() *True_falseContext { + var p = new(True_falseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_true_false + return p +} + +func InitEmptyTrue_falseContext(p *True_falseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_true_false +} + +func (*True_falseContext) IsTrue_falseContext() {} + +func NewTrue_falseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *True_falseContext { + var p = new(True_falseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_true_false + + return p +} + +func (s *True_falseContext) GetParser() antlr.Parser { return s.parser } + +func (s *True_falseContext) TRUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUE, 0) +} + +func (s *True_falseContext) FALSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFALSE, 0) +} + +func (s *True_falseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *True_falseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *True_falseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTrue_false(s) + } +} + +func (s *True_falseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTrue_false(s) + } +} + +func (s *True_falseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTrue_false(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) True_false() (localctx ITrue_falseContext) { + localctx = NewTrue_falseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, SnowflakeParserRULE_true_false) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8255) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserFALSE || _la == SnowflakeParserTRUE) { + 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 +} + +// IEnableContext is an interface to support dynamic dispatch. +type IEnableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + + // IsEnableContext differentiates from other interfaces. + IsEnableContext() +} + +type EnableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnableContext() *EnableContext { + var p = new(EnableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_enable + return p +} + +func InitEmptyEnableContext(p *EnableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_enable +} + +func (*EnableContext) IsEnableContext() {} + +func NewEnableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EnableContext { + var p = new(EnableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_enable + + return p +} + +func (s *EnableContext) GetParser() antlr.Parser { return s.parser } + +func (s *EnableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *EnableContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *EnableContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *EnableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EnableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EnableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterEnable(s) + } +} + +func (s *EnableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitEnable(s) + } +} + +func (s *EnableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitEnable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Enable() (localctx IEnableContext) { + localctx = NewEnableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, SnowflakeParserRULE_enable) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8257) + p.Match(SnowflakeParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8258) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8259) + p.True_false() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRefresh_on_createContext is an interface to support dynamic dispatch. +type IRefresh_on_createContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFRESH_ON_CREATE() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + + // IsRefresh_on_createContext differentiates from other interfaces. + IsRefresh_on_createContext() +} + +type Refresh_on_createContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRefresh_on_createContext() *Refresh_on_createContext { + var p = new(Refresh_on_createContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_refresh_on_create + return p +} + +func InitEmptyRefresh_on_createContext(p *Refresh_on_createContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_refresh_on_create +} + +func (*Refresh_on_createContext) IsRefresh_on_createContext() {} + +func NewRefresh_on_createContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Refresh_on_createContext { + var p = new(Refresh_on_createContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_refresh_on_create + + return p +} + +func (s *Refresh_on_createContext) GetParser() antlr.Parser { return s.parser } + +func (s *Refresh_on_createContext) REFRESH_ON_CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH_ON_CREATE, 0) +} + +func (s *Refresh_on_createContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Refresh_on_createContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Refresh_on_createContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Refresh_on_createContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Refresh_on_createContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRefresh_on_create(s) + } +} + +func (s *Refresh_on_createContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRefresh_on_create(s) + } +} + +func (s *Refresh_on_createContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRefresh_on_create(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Refresh_on_create() (localctx IRefresh_on_createContext) { + localctx = NewRefresh_on_createContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, SnowflakeParserRULE_refresh_on_create) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8261) + p.Match(SnowflakeParserREFRESH_ON_CREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8262) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8263) + p.True_false() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAuto_refreshContext is an interface to support dynamic dispatch. +type IAuto_refreshContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTO_REFRESH() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + + // IsAuto_refreshContext differentiates from other interfaces. + IsAuto_refreshContext() +} + +type Auto_refreshContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuto_refreshContext() *Auto_refreshContext { + var p = new(Auto_refreshContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_auto_refresh + return p +} + +func InitEmptyAuto_refreshContext(p *Auto_refreshContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_auto_refresh +} + +func (*Auto_refreshContext) IsAuto_refreshContext() {} + +func NewAuto_refreshContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auto_refreshContext { + var p = new(Auto_refreshContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_auto_refresh + + return p +} + +func (s *Auto_refreshContext) GetParser() antlr.Parser { return s.parser } + +func (s *Auto_refreshContext) AUTO_REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_REFRESH, 0) +} + +func (s *Auto_refreshContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Auto_refreshContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Auto_refreshContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Auto_refreshContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Auto_refreshContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAuto_refresh(s) + } +} + +func (s *Auto_refreshContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAuto_refresh(s) + } +} + +func (s *Auto_refreshContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAuto_refresh(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Auto_refresh() (localctx IAuto_refreshContext) { + localctx = NewAuto_refreshContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, SnowflakeParserRULE_auto_refresh) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8265) + p.Match(SnowflakeParserAUTO_REFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8266) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8267) + p.True_false() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INotification_integrationContext is an interface to support dynamic dispatch. +type INotification_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOTIFICATION_INTEGRATION() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsNotification_integrationContext differentiates from other interfaces. + IsNotification_integrationContext() +} + +type Notification_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNotification_integrationContext() *Notification_integrationContext { + var p = new(Notification_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_notification_integration + return p +} + +func InitEmptyNotification_integrationContext(p *Notification_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_notification_integration +} + +func (*Notification_integrationContext) IsNotification_integrationContext() {} + +func NewNotification_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Notification_integrationContext { + var p = new(Notification_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_notification_integration + + return p +} + +func (s *Notification_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Notification_integrationContext) NOTIFICATION_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION_INTEGRATION, 0) +} + +func (s *Notification_integrationContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Notification_integrationContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Notification_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Notification_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Notification_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterNotification_integration(s) + } +} + +func (s *Notification_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitNotification_integration(s) + } +} + +func (s *Notification_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitNotification_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Notification_integration() (localctx INotification_integrationContext) { + localctx = NewNotification_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, SnowflakeParserRULE_notification_integration) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8269) + p.Match(SnowflakeParserNOTIFICATION_INTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8270) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8271) + p.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 +} + +// IDirectory_table_paramsContext is an interface to support dynamic dispatch. +type IDirectory_table_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DIRECTORY() antlr.TerminalNode + EQ() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Enable() IEnableContext + RR_BRACKET() antlr.TerminalNode + Refresh_on_create() IRefresh_on_createContext + Auto_refresh() IAuto_refreshContext + Notification_integration() INotification_integrationContext + + // IsDirectory_table_paramsContext differentiates from other interfaces. + IsDirectory_table_paramsContext() +} + +type Directory_table_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDirectory_table_paramsContext() *Directory_table_paramsContext { + var p = new(Directory_table_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_directory_table_params + return p +} + +func InitEmptyDirectory_table_paramsContext(p *Directory_table_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_directory_table_params +} + +func (*Directory_table_paramsContext) IsDirectory_table_paramsContext() {} + +func NewDirectory_table_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Directory_table_paramsContext { + var p = new(Directory_table_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_directory_table_params + + return p +} + +func (s *Directory_table_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Directory_table_paramsContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDIRECTORY, 0) +} + +func (s *Directory_table_paramsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Directory_table_paramsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Directory_table_paramsContext) Enable() IEnableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnableContext) +} + +func (s *Directory_table_paramsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Directory_table_paramsContext) Refresh_on_create() IRefresh_on_createContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRefresh_on_createContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRefresh_on_createContext) +} + +func (s *Directory_table_paramsContext) Auto_refresh() IAuto_refreshContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuto_refreshContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuto_refreshContext) +} + +func (s *Directory_table_paramsContext) Notification_integration() INotification_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INotification_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INotification_integrationContext) +} + +func (s *Directory_table_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Directory_table_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Directory_table_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDirectory_table_params(s) + } +} + +func (s *Directory_table_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDirectory_table_params(s) + } +} + +func (s *Directory_table_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDirectory_table_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Directory_table_params() (localctx IDirectory_table_paramsContext) { + localctx = NewDirectory_table_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, SnowflakeParserRULE_directory_table_params) + var _la int + + p.SetState(8324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1007, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8273) + p.Match(SnowflakeParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8274) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8275) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8276) + p.Enable() + } + p.SetState(8278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREFRESH_ON_CREATE { + { + p.SetState(8277) + p.Refresh_on_create() + } + + } + { + p.SetState(8280) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8282) + p.Match(SnowflakeParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8283) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8284) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8285) + p.Enable() + } + p.SetState(8287) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREFRESH_ON_CREATE { + { + p.SetState(8286) + p.Refresh_on_create() + } + + } + p.SetState(8290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAUTO_REFRESH { + { + p.SetState(8289) + p.Auto_refresh() + } + + } + { + p.SetState(8292) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8294) + p.Match(SnowflakeParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8295) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8296) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8297) + p.Enable() + } + p.SetState(8299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAUTO_REFRESH { + { + p.SetState(8298) + p.Auto_refresh() + } + + } + p.SetState(8302) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREFRESH_ON_CREATE { + { + p.SetState(8301) + p.Refresh_on_create() + } + + } + p.SetState(8305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFICATION_INTEGRATION { + { + p.SetState(8304) + p.Notification_integration() + } + + } + { + p.SetState(8307) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8309) + p.Match(SnowflakeParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8310) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8311) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8312) + p.Enable() + } + p.SetState(8314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserREFRESH_ON_CREATE { + { + p.SetState(8313) + p.Refresh_on_create() + } + + } + p.SetState(8317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAUTO_REFRESH { + { + p.SetState(8316) + p.Auto_refresh() + } + + } + p.SetState(8320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOTIFICATION_INTEGRATION { + { + p.SetState(8319) + p.Notification_integration() + } + + } + { + p.SetState(8322) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// ICreate_stageContext is an interface to support dynamic dispatch. +type ICreate_stageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + STAGE() antlr.TerminalNode + Object_name() IObject_nameContext + Or_replace() IOr_replaceContext + TEMPORARY() antlr.TerminalNode + If_not_exists() IIf_not_existsContext + Internal_stage_params() IInternal_stage_paramsContext + Directory_table_params() IDirectory_table_paramsContext + FILE_FORMAT() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + COPY_OPTIONS_() antlr.TerminalNode + Copy_options() ICopy_optionsContext + With_tags() IWith_tagsContext + Comment_clause() IComment_clauseContext + FORMAT_NAME() antlr.TerminalNode + String_() IStringContext + TYPE() antlr.TerminalNode + CSV() antlr.TerminalNode + JSON() antlr.TerminalNode + AVRO() antlr.TerminalNode + ORC() antlr.TerminalNode + PARQUET() antlr.TerminalNode + XML() antlr.TerminalNode + AllFormat_type_options() []IFormat_type_optionsContext + Format_type_options(i int) IFormat_type_optionsContext + External_stage_params() IExternal_stage_paramsContext + + // IsCreate_stageContext differentiates from other interfaces. + IsCreate_stageContext() +} + +type Create_stageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_stageContext() *Create_stageContext { + var p = new(Create_stageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_stage + return p +} + +func InitEmptyCreate_stageContext(p *Create_stageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_stage +} + +func (*Create_stageContext) IsCreate_stageContext() {} + +func NewCreate_stageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_stageContext { + var p = new(Create_stageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_stage + + return p +} + +func (s *Create_stageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_stageContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_stageContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Create_stageContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_stageContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_stageContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEMPORARY, 0) +} + +func (s *Create_stageContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_stageContext) Internal_stage_params() IInternal_stage_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInternal_stage_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInternal_stage_paramsContext) +} + +func (s *Create_stageContext) Directory_table_params() IDirectory_table_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_table_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_table_paramsContext) +} + +func (s *Create_stageContext) FILE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE_FORMAT, 0) +} + +func (s *Create_stageContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_stageContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_stageContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_stageContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_stageContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_stageContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_stageContext) COPY_OPTIONS_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY_OPTIONS_, 0) +} + +func (s *Create_stageContext) 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 *Create_stageContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Create_stageContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_stageContext) FORMAT_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT_NAME, 0) +} + +func (s *Create_stageContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_stageContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_stageContext) CSV() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCSV, 0) +} + +func (s *Create_stageContext) JSON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON, 0) +} + +func (s *Create_stageContext) AVRO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVRO, 0) +} + +func (s *Create_stageContext) ORC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORC, 0) +} + +func (s *Create_stageContext) PARQUET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARQUET, 0) +} + +func (s *Create_stageContext) XML() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXML, 0) +} + +func (s *Create_stageContext) AllFormat_type_options() []IFormat_type_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + len++ + } + } + + tst := make([]IFormat_type_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFormat_type_optionsContext); ok { + tst[i] = t.(IFormat_type_optionsContext) + i++ + } + } + + return tst +} + +func (s *Create_stageContext) Format_type_options(i int) IFormat_type_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFormat_type_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFormat_type_optionsContext) +} + +func (s *Create_stageContext) External_stage_params() IExternal_stage_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_stage_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_stage_paramsContext) +} + +func (s *Create_stageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_stageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_stageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_stage(s) + } +} + +func (s *Create_stageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_stage(s) + } +} + +func (s *Create_stageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_stage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_stage() (localctx ICreate_stageContext) { + localctx = NewCreate_stageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, SnowflakeParserRULE_create_stage) + var _la int + + p.SetState(8428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1029, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8326) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8327) + p.Or_replace() + } + + } + p.SetState(8331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTEMPORARY { + { + p.SetState(8330) + p.Match(SnowflakeParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8333) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8335) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1010, p.GetParserRuleContext()) == 1 { + { + p.SetState(8334) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8337) + p.Object_name() + } + p.SetState(8339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserENCRYPTION || _la == SnowflakeParserTYPE { + { + p.SetState(8338) + p.Internal_stage_params() + } + + } + p.SetState(8342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDIRECTORY { + { + p.SetState(8341) + p.Directory_table_params() + } + + } + p.SetState(8362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILE_FORMAT { + { + p.SetState(8344) + p.Match(SnowflakeParserFILE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8345) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8346) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserFORMAT_NAME: + { + p.SetState(8347) + p.Match(SnowflakeParserFORMAT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8348) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8349) + p.String_() + } + + case SnowflakeParserTYPE: + { + p.SetState(8350) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8351) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8352) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAVRO || _la == SnowflakeParserCSV || _la == SnowflakeParserJSON || _la == SnowflakeParserORC || _la == SnowflakeParserPARQUET || _la == SnowflakeParserXML) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserALLOW_DUPLICATE || ((int64((_la-97)) & ^0x3f) == 0 && ((int64(1)<<(_la-97))&18437) != 0) || _la == SnowflakeParserCOMPRESSION || _la == SnowflakeParserDATE_FORMAT || ((int64((_la-230)) & ^0x3f) == 0 && ((int64(1)<<(_la-230))&879628696688641) != 0) || ((int64((_la-312)) & ^0x3f) == 0 && ((int64(1)<<(_la-312))&1152925902653358099) != 0) || _la == SnowflakeParserLZO || _la == SnowflakeParserNONE || _la == SnowflakeParserNULL_IF || ((int64((_la-615)) & ^0x3f) == 0 && ((int64(1)<<(_la-615))&1125917086711809) != 0) || _la == SnowflakeParserREPLACE_INVALID_CHARACTERS || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&8070450532247929043) != 0) || ((int64((_la-906)) & ^0x3f) == 0 && ((int64(1)<<(_la-906))&34359746561) != 0) || _la == SnowflakeParserZSTD { + { + p.SetState(8353) + p.Format_type_options() + } + + p.SetState(8358) + 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 + } + { + p.SetState(8361) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY_OPTIONS_ { + { + p.SetState(8364) + p.Match(SnowflakeParserCOPY_OPTIONS_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8365) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8366) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8367) + p.Copy_options() + } + { + p.SetState(8368) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(8372) + p.With_tags() + } + + } + p.SetState(8376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8375) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8378) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8379) + p.Or_replace() + } + + } + p.SetState(8383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTEMPORARY { + { + p.SetState(8382) + p.Match(SnowflakeParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8385) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8387) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1021, p.GetParserRuleContext()) == 1 { + { + p.SetState(8386) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8389) + p.Object_name() + } + { + p.SetState(8390) + p.External_stage_params() + } + p.SetState(8392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDIRECTORY { + { + p.SetState(8391) + p.Directory_table_params() + } + + } + p.SetState(8412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFILE_FORMAT { + { + p.SetState(8394) + p.Match(SnowflakeParserFILE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8395) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8396) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserFORMAT_NAME: + { + p.SetState(8397) + p.Match(SnowflakeParserFORMAT_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8398) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8399) + p.String_() + } + + case SnowflakeParserTYPE: + { + p.SetState(8400) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8401) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8402) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAVRO || _la == SnowflakeParserCSV || _la == SnowflakeParserJSON || _la == SnowflakeParserORC || _la == SnowflakeParserPARQUET || _la == SnowflakeParserXML) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserALLOW_DUPLICATE || ((int64((_la-97)) & ^0x3f) == 0 && ((int64(1)<<(_la-97))&18437) != 0) || _la == SnowflakeParserCOMPRESSION || _la == SnowflakeParserDATE_FORMAT || ((int64((_la-230)) & ^0x3f) == 0 && ((int64(1)<<(_la-230))&879628696688641) != 0) || ((int64((_la-312)) & ^0x3f) == 0 && ((int64(1)<<(_la-312))&1152925902653358099) != 0) || _la == SnowflakeParserLZO || _la == SnowflakeParserNONE || _la == SnowflakeParserNULL_IF || ((int64((_la-615)) & ^0x3f) == 0 && ((int64(1)<<(_la-615))&1125917086711809) != 0) || _la == SnowflakeParserREPLACE_INVALID_CHARACTERS || ((int64((_la-803)) & ^0x3f) == 0 && ((int64(1)<<(_la-803))&8070450532247929043) != 0) || ((int64((_la-906)) & ^0x3f) == 0 && ((int64(1)<<(_la-906))&34359746561) != 0) || _la == SnowflakeParserZSTD { + { + p.SetState(8403) + p.Format_type_options() + } + + p.SetState(8408) + 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 + } + { + p.SetState(8411) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY_OPTIONS_ { + { + p.SetState(8414) + p.Match(SnowflakeParserCOPY_OPTIONS_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8415) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8416) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8417) + p.Copy_options() + } + { + p.SetState(8418) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(8422) + p.With_tags() + } + + } + p.SetState(8426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8425) + p.Comment_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 +} + +// ICloud_provider_paramsContext is an interface to support dynamic dispatch. +type ICloud_provider_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORAGE_PROVIDER() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + S3() antlr.TerminalNode + STORAGE_AWS_ROLE_ARN() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + STORAGE_AWS_OBJECT_ACL() antlr.TerminalNode + GCS() antlr.TerminalNode + AZURE() antlr.TerminalNode + AZURE_TENANT_ID() antlr.TerminalNode + + // IsCloud_provider_paramsContext differentiates from other interfaces. + IsCloud_provider_paramsContext() +} + +type Cloud_provider_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCloud_provider_paramsContext() *Cloud_provider_paramsContext { + var p = new(Cloud_provider_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params + return p +} + +func InitEmptyCloud_provider_paramsContext(p *Cloud_provider_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params +} + +func (*Cloud_provider_paramsContext) IsCloud_provider_paramsContext() {} + +func NewCloud_provider_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cloud_provider_paramsContext { + var p = new(Cloud_provider_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params + + return p +} + +func (s *Cloud_provider_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cloud_provider_paramsContext) STORAGE_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_PROVIDER, 0) +} + +func (s *Cloud_provider_paramsContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Cloud_provider_paramsContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Cloud_provider_paramsContext) S3() antlr.TerminalNode { + return s.GetToken(SnowflakeParserS3, 0) +} + +func (s *Cloud_provider_paramsContext) STORAGE_AWS_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_AWS_ROLE_ARN, 0) +} + +func (s *Cloud_provider_paramsContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Cloud_provider_paramsContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Cloud_provider_paramsContext) STORAGE_AWS_OBJECT_ACL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_AWS_OBJECT_ACL, 0) +} + +func (s *Cloud_provider_paramsContext) GCS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCS, 0) +} + +func (s *Cloud_provider_paramsContext) AZURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE, 0) +} + +func (s *Cloud_provider_paramsContext) AZURE_TENANT_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_TENANT_ID, 0) +} + +func (s *Cloud_provider_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cloud_provider_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cloud_provider_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCloud_provider_params(s) + } +} + +func (s *Cloud_provider_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCloud_provider_params(s) + } +} + +func (s *Cloud_provider_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCloud_provider_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Cloud_provider_params() (localctx ICloud_provider_paramsContext) { + localctx = NewCloud_provider_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, SnowflakeParserRULE_cloud_provider_params) + var _la int + + p.SetState(8450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1031, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8430) + p.Match(SnowflakeParserSTORAGE_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8431) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8432) + p.Match(SnowflakeParserS3) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8433) + p.Match(SnowflakeParserSTORAGE_AWS_ROLE_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8434) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8435) + p.String_() + } + p.SetState(8439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE_AWS_OBJECT_ACL { + { + p.SetState(8436) + p.Match(SnowflakeParserSTORAGE_AWS_OBJECT_ACL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8437) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8438) + p.String_() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8441) + p.Match(SnowflakeParserSTORAGE_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8442) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8443) + p.Match(SnowflakeParserGCS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8444) + p.Match(SnowflakeParserSTORAGE_PROVIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8445) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8446) + p.Match(SnowflakeParserAZURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8447) + p.Match(SnowflakeParserAZURE_TENANT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8448) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8449) + p.String_() + } + + 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 +} + +// ICloud_provider_params2Context is an interface to support dynamic dispatch. +type ICloud_provider_params2Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORAGE_AWS_ROLE_ARN() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + STORAGE_AWS_OBJECT_ACL() antlr.TerminalNode + AZURE_TENANT_ID() antlr.TerminalNode + + // IsCloud_provider_params2Context differentiates from other interfaces. + IsCloud_provider_params2Context() +} + +type Cloud_provider_params2Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCloud_provider_params2Context() *Cloud_provider_params2Context { + var p = new(Cloud_provider_params2Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params2 + return p +} + +func InitEmptyCloud_provider_params2Context(p *Cloud_provider_params2Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params2 +} + +func (*Cloud_provider_params2Context) IsCloud_provider_params2Context() {} + +func NewCloud_provider_params2Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cloud_provider_params2Context { + var p = new(Cloud_provider_params2Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params2 + + return p +} + +func (s *Cloud_provider_params2Context) GetParser() antlr.Parser { return s.parser } + +func (s *Cloud_provider_params2Context) STORAGE_AWS_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_AWS_ROLE_ARN, 0) +} + +func (s *Cloud_provider_params2Context) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Cloud_provider_params2Context) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Cloud_provider_params2Context) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Cloud_provider_params2Context) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Cloud_provider_params2Context) STORAGE_AWS_OBJECT_ACL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_AWS_OBJECT_ACL, 0) +} + +func (s *Cloud_provider_params2Context) AZURE_TENANT_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_TENANT_ID, 0) +} + +func (s *Cloud_provider_params2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cloud_provider_params2Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cloud_provider_params2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCloud_provider_params2(s) + } +} + +func (s *Cloud_provider_params2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCloud_provider_params2(s) + } +} + +func (s *Cloud_provider_params2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCloud_provider_params2(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Cloud_provider_params2() (localctx ICloud_provider_params2Context) { + localctx = NewCloud_provider_params2Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, SnowflakeParserRULE_cloud_provider_params2) + var _la int + + p.SetState(8463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTORAGE_AWS_ROLE_ARN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8452) + p.Match(SnowflakeParserSTORAGE_AWS_ROLE_ARN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8453) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8454) + p.String_() + } + p.SetState(8458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE_AWS_OBJECT_ACL { + { + p.SetState(8455) + p.Match(SnowflakeParserSTORAGE_AWS_OBJECT_ACL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8456) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8457) + p.String_() + } + + } + + case SnowflakeParserAZURE_TENANT_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8460) + p.Match(SnowflakeParserAZURE_TENANT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8461) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8462) + p.String_() + } + + 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 +} + +// ICloud_provider_params3Context is an interface to support dynamic dispatch. +type ICloud_provider_params3Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTEGRATION() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsCloud_provider_params3Context differentiates from other interfaces. + IsCloud_provider_params3Context() +} + +type Cloud_provider_params3Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCloud_provider_params3Context() *Cloud_provider_params3Context { + var p = new(Cloud_provider_params3Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params3 + return p +} + +func InitEmptyCloud_provider_params3Context(p *Cloud_provider_params3Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params3 +} + +func (*Cloud_provider_params3Context) IsCloud_provider_params3Context() {} + +func NewCloud_provider_params3Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cloud_provider_params3Context { + var p = new(Cloud_provider_params3Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_cloud_provider_params3 + + return p +} + +func (s *Cloud_provider_params3Context) GetParser() antlr.Parser { return s.parser } + +func (s *Cloud_provider_params3Context) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Cloud_provider_params3Context) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Cloud_provider_params3Context) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Cloud_provider_params3Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cloud_provider_params3Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cloud_provider_params3Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCloud_provider_params3(s) + } +} + +func (s *Cloud_provider_params3Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCloud_provider_params3(s) + } +} + +func (s *Cloud_provider_params3Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCloud_provider_params3(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Cloud_provider_params3() (localctx ICloud_provider_params3Context) { + localctx = NewCloud_provider_params3Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, SnowflakeParserRULE_cloud_provider_params3) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8465) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8466) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8467) + p.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 +} + +// ICreate_storage_integrationContext is an interface to support dynamic dispatch. +type ICreate_storage_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + STORAGE() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + TYPE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + EXTERNAL_STAGE() antlr.TerminalNode + Cloud_provider_params() ICloud_provider_paramsContext + ENABLED() antlr.TerminalNode + True_false() ITrue_falseContext + STORAGE_ALLOWED_LOCATIONS() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllString_list() []IString_listContext + String_list(i int) IString_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + STORAGE_BLOCKED_LOCATIONS() antlr.TerminalNode + Comment_clause() IComment_clauseContext + + // IsCreate_storage_integrationContext differentiates from other interfaces. + IsCreate_storage_integrationContext() +} + +type Create_storage_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_storage_integrationContext() *Create_storage_integrationContext { + var p = new(Create_storage_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_storage_integration + return p +} + +func InitEmptyCreate_storage_integrationContext(p *Create_storage_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_storage_integration +} + +func (*Create_storage_integrationContext) IsCreate_storage_integrationContext() {} + +func NewCreate_storage_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_storage_integrationContext { + var p = new(Create_storage_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_storage_integration + + return p +} + +func (s *Create_storage_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_storage_integrationContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_storage_integrationContext) STORAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE, 0) +} + +func (s *Create_storage_integrationContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Create_storage_integrationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_storage_integrationContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Create_storage_integrationContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_storage_integrationContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_storage_integrationContext) EXTERNAL_STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_STAGE, 0) +} + +func (s *Create_storage_integrationContext) Cloud_provider_params() ICloud_provider_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICloud_provider_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICloud_provider_paramsContext) +} + +func (s *Create_storage_integrationContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Create_storage_integrationContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_storage_integrationContext) STORAGE_ALLOWED_LOCATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, 0) +} + +func (s *Create_storage_integrationContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_storage_integrationContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_storage_integrationContext) AllString_list() []IString_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IString_listContext); ok { + len++ + } + } + + tst := make([]IString_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IString_listContext); ok { + tst[i] = t.(IString_listContext) + i++ + } + } + + return tst +} + +func (s *Create_storage_integrationContext) String_list(i int) IString_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IString_listContext) +} + +func (s *Create_storage_integrationContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_storage_integrationContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_storage_integrationContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_storage_integrationContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_storage_integrationContext) STORAGE_BLOCKED_LOCATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, 0) +} + +func (s *Create_storage_integrationContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_storage_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_storage_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_storage_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_storage_integration(s) + } +} + +func (s *Create_storage_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_storage_integration(s) + } +} + +func (s *Create_storage_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_storage_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_storage_integration() (localctx ICreate_storage_integrationContext) { + localctx = NewCreate_storage_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, SnowflakeParserRULE_create_storage_integration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8469) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8470) + p.Or_replace() + } + + } + { + p.SetState(8473) + p.Match(SnowflakeParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8474) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8476) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1035, p.GetParserRuleContext()) == 1 { + { + p.SetState(8475) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8478) + p.Id_() + } + { + p.SetState(8479) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8480) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8481) + p.Match(SnowflakeParserEXTERNAL_STAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8482) + p.Cloud_provider_params() + } + { + p.SetState(8483) + p.Match(SnowflakeParserENABLED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8484) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8485) + p.True_false() + } + { + p.SetState(8486) + p.Match(SnowflakeParserSTORAGE_ALLOWED_LOCATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8487) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8488) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8489) + p.String_list() + } + { + p.SetState(8490) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTORAGE_BLOCKED_LOCATIONS { + { + p.SetState(8491) + p.Match(SnowflakeParserSTORAGE_BLOCKED_LOCATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8492) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8493) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8494) + p.String_list() + } + { + p.SetState(8495) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8499) + p.Comment_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 +} + +// ICopy_grantsContext is an interface to support dynamic dispatch. +type ICopy_grantsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COPY() antlr.TerminalNode + GRANTS() antlr.TerminalNode + + // IsCopy_grantsContext differentiates from other interfaces. + IsCopy_grantsContext() +} + +type Copy_grantsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCopy_grantsContext() *Copy_grantsContext { + var p = new(Copy_grantsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_copy_grants + return p +} + +func InitEmptyCopy_grantsContext(p *Copy_grantsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_copy_grants +} + +func (*Copy_grantsContext) IsCopy_grantsContext() {} + +func NewCopy_grantsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Copy_grantsContext { + var p = new(Copy_grantsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_copy_grants + + return p +} + +func (s *Copy_grantsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Copy_grantsContext) COPY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY, 0) +} + +func (s *Copy_grantsContext) GRANTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANTS, 0) +} + +func (s *Copy_grantsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Copy_grantsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Copy_grantsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCopy_grants(s) + } +} + +func (s *Copy_grantsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCopy_grants(s) + } +} + +func (s *Copy_grantsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCopy_grants(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Copy_grants() (localctx ICopy_grantsContext) { + localctx = NewCopy_grantsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, SnowflakeParserRULE_copy_grants) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8502) + p.Match(SnowflakeParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8503) + p.Match(SnowflakeParserGRANTS) + 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 +} + +// IAppend_onlyContext is an interface to support dynamic dispatch. +type IAppend_onlyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + APPEND_ONLY() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + + // IsAppend_onlyContext differentiates from other interfaces. + IsAppend_onlyContext() +} + +type Append_onlyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAppend_onlyContext() *Append_onlyContext { + var p = new(Append_onlyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_append_only + return p +} + +func InitEmptyAppend_onlyContext(p *Append_onlyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_append_only +} + +func (*Append_onlyContext) IsAppend_onlyContext() {} + +func NewAppend_onlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Append_onlyContext { + var p = new(Append_onlyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_append_only + + return p +} + +func (s *Append_onlyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Append_onlyContext) APPEND_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPPEND_ONLY, 0) +} + +func (s *Append_onlyContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Append_onlyContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Append_onlyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Append_onlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Append_onlyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAppend_only(s) + } +} + +func (s *Append_onlyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAppend_only(s) + } +} + +func (s *Append_onlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAppend_only(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Append_only() (localctx IAppend_onlyContext) { + localctx = NewAppend_onlyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 474, SnowflakeParserRULE_append_only) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8505) + p.Match(SnowflakeParserAPPEND_ONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8506) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8507) + p.True_false() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_onlyContext is an interface to support dynamic dispatch. +type IInsert_onlyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSERT_ONLY() antlr.TerminalNode + EQ() antlr.TerminalNode + TRUE() antlr.TerminalNode + + // IsInsert_onlyContext differentiates from other interfaces. + IsInsert_onlyContext() +} + +type Insert_onlyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_onlyContext() *Insert_onlyContext { + var p = new(Insert_onlyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_insert_only + return p +} + +func InitEmptyInsert_onlyContext(p *Insert_onlyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_insert_only +} + +func (*Insert_onlyContext) IsInsert_onlyContext() {} + +func NewInsert_onlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_onlyContext { + var p = new(Insert_onlyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_insert_only + + return p +} + +func (s *Insert_onlyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_onlyContext) INSERT_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINSERT_ONLY, 0) +} + +func (s *Insert_onlyContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Insert_onlyContext) TRUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUE, 0) +} + +func (s *Insert_onlyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_onlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_onlyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterInsert_only(s) + } +} + +func (s *Insert_onlyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitInsert_only(s) + } +} + +func (s *Insert_onlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitInsert_only(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Insert_only() (localctx IInsert_onlyContext) { + localctx = NewInsert_onlyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 476, SnowflakeParserRULE_insert_only) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8509) + p.Match(SnowflakeParserINSERT_ONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8510) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8511) + p.Match(SnowflakeParserTRUE) + 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 +} + +// IShow_initial_rowsContext is an interface to support dynamic dispatch. +type IShow_initial_rowsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW_INITIAL_ROWS() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + + // IsShow_initial_rowsContext differentiates from other interfaces. + IsShow_initial_rowsContext() +} + +type Show_initial_rowsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_initial_rowsContext() *Show_initial_rowsContext { + var p = new(Show_initial_rowsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_initial_rows + return p +} + +func InitEmptyShow_initial_rowsContext(p *Show_initial_rowsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_initial_rows +} + +func (*Show_initial_rowsContext) IsShow_initial_rowsContext() {} + +func NewShow_initial_rowsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_initial_rowsContext { + var p = new(Show_initial_rowsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_initial_rows + + return p +} + +func (s *Show_initial_rowsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_initial_rowsContext) SHOW_INITIAL_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW_INITIAL_ROWS, 0) +} + +func (s *Show_initial_rowsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Show_initial_rowsContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Show_initial_rowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_initial_rowsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_initial_rowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_initial_rows(s) + } +} + +func (s *Show_initial_rowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_initial_rows(s) + } +} + +func (s *Show_initial_rowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_initial_rows(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_initial_rows() (localctx IShow_initial_rowsContext) { + localctx = NewShow_initial_rowsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 478, SnowflakeParserRULE_show_initial_rows) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8513) + p.Match(SnowflakeParserSHOW_INITIAL_ROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8514) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8515) + p.True_false() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStream_timeContext is an interface to support dynamic dispatch. +type IStream_timeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + At_before1() IAt_before1Context + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + ASSOC() antlr.TerminalNode + String_() IStringContext + OFFSET() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + Id_() IId_Context + STREAM() antlr.TerminalNode + + // IsStream_timeContext differentiates from other interfaces. + IsStream_timeContext() +} + +type Stream_timeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStream_timeContext() *Stream_timeContext { + var p = new(Stream_timeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stream_time + return p +} + +func InitEmptyStream_timeContext(p *Stream_timeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_stream_time +} + +func (*Stream_timeContext) IsStream_timeContext() {} + +func NewStream_timeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stream_timeContext { + var p = new(Stream_timeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_stream_time + + return p +} + +func (s *Stream_timeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stream_timeContext) At_before1() IAt_before1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAt_before1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAt_before1Context) +} + +func (s *Stream_timeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Stream_timeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Stream_timeContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP, 0) +} + +func (s *Stream_timeContext) ASSOC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASSOC, 0) +} + +func (s *Stream_timeContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Stream_timeContext) OFFSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFFSET, 0) +} + +func (s *Stream_timeContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT, 0) +} + +func (s *Stream_timeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Stream_timeContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Stream_timeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stream_timeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stream_timeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterStream_time(s) + } +} + +func (s *Stream_timeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitStream_time(s) + } +} + +func (s *Stream_timeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitStream_time(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Stream_time() (localctx IStream_timeContext) { + localctx = NewStream_timeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 480, SnowflakeParserRULE_stream_time) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8517) + p.At_before1() + } + { + p.SetState(8518) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserTIMESTAMP: + { + p.SetState(8519) + p.Match(SnowflakeParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8520) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8521) + p.String_() + } + + case SnowflakeParserOFFSET: + { + p.SetState(8522) + p.Match(SnowflakeParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8523) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8524) + p.String_() + } + + case SnowflakeParserSTATEMENT: + { + p.SetState(8525) + p.Match(SnowflakeParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8526) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8527) + p.Id_() + } + + case SnowflakeParserSTREAM: + { + p.SetState(8528) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8529) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8530) + p.String_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(8533) + p.Match(SnowflakeParserRR_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 +} + +// ICreate_streamContext is an interface to support dynamic dispatch. +type ICreate_streamContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + STREAM() antlr.TerminalNode + AllObject_name() []IObject_nameContext + Object_name(i int) IObject_nameContext + ON() antlr.TerminalNode + TABLE() antlr.TerminalNode + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + Copy_grants() ICopy_grantsContext + Stream_time() IStream_timeContext + Append_only() IAppend_onlyContext + Show_initial_rows() IShow_initial_rowsContext + Comment_clause() IComment_clauseContext + EXTERNAL() antlr.TerminalNode + Insert_only() IInsert_onlyContext + STAGE() antlr.TerminalNode + VIEW() antlr.TerminalNode + + // IsCreate_streamContext differentiates from other interfaces. + IsCreate_streamContext() +} + +type Create_streamContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_streamContext() *Create_streamContext { + var p = new(Create_streamContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_stream + return p +} + +func InitEmptyCreate_streamContext(p *Create_streamContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_stream +} + +func (*Create_streamContext) IsCreate_streamContext() {} + +func NewCreate_streamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_streamContext { + var p = new(Create_streamContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_stream + + return p +} + +func (s *Create_streamContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_streamContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_streamContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Create_streamContext) AllObject_name() []IObject_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_nameContext); ok { + len++ + } + } + + tst := make([]IObject_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_nameContext); ok { + tst[i] = t.(IObject_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_streamContext) Object_name(i int) IObject_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_streamContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Create_streamContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Create_streamContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_streamContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_streamContext) Copy_grants() ICopy_grantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_grantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_grantsContext) +} + +func (s *Create_streamContext) Stream_time() IStream_timeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStream_timeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStream_timeContext) +} + +func (s *Create_streamContext) Append_only() IAppend_onlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAppend_onlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAppend_onlyContext) +} + +func (s *Create_streamContext) Show_initial_rows() IShow_initial_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_initial_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_initial_rowsContext) +} + +func (s *Create_streamContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_streamContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Create_streamContext) Insert_only() IInsert_onlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_onlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_onlyContext) +} + +func (s *Create_streamContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Create_streamContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Create_streamContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_streamContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_streamContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_stream(s) + } +} + +func (s *Create_streamContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_stream(s) + } +} + +func (s *Create_streamContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_stream(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_stream() (localctx ICreate_streamContext) { + localctx = NewCreate_streamContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 482, SnowflakeParserRULE_create_stream) + var _la int + + p.SetState(8632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1063, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8535) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8536) + p.Or_replace() + } + + } + { + p.SetState(8539) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8541) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1040, p.GetParserRuleContext()) == 1 { + { + p.SetState(8540) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8543) + p.Object_name() + } + p.SetState(8545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(8544) + p.Copy_grants() + } + + } + { + p.SetState(8547) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8548) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8549) + p.Object_name() + } + p.SetState(8551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAT_KEYWORD || _la == SnowflakeParserBEFORE { + { + p.SetState(8550) + p.Stream_time() + } + + } + p.SetState(8554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPPEND_ONLY { + { + p.SetState(8553) + p.Append_only() + } + + } + p.SetState(8557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSHOW_INITIAL_ROWS { + { + p.SetState(8556) + p.Show_initial_rows() + } + + } + p.SetState(8560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8559) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8562) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8563) + p.Or_replace() + } + + } + { + p.SetState(8566) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8568) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1047, p.GetParserRuleContext()) == 1 { + { + p.SetState(8567) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8570) + p.Object_name() + } + p.SetState(8572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(8571) + p.Copy_grants() + } + + } + { + p.SetState(8574) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8575) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8576) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8577) + p.Object_name() + } + p.SetState(8579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAT_KEYWORD || _la == SnowflakeParserBEFORE { + { + p.SetState(8578) + p.Stream_time() + } + + } + p.SetState(8582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserINSERT_ONLY { + { + p.SetState(8581) + p.Insert_only() + } + + } + p.SetState(8585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8584) + p.Comment_clause() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8587) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8589) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8588) + p.Or_replace() + } + + } + { + p.SetState(8591) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8593) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1053, p.GetParserRuleContext()) == 1 { + { + p.SetState(8592) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8595) + p.Object_name() + } + p.SetState(8597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(8596) + p.Copy_grants() + } + + } + { + p.SetState(8599) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8600) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8601) + p.Object_name() + } + p.SetState(8603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8602) + p.Comment_clause() + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(8605) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8606) + p.Or_replace() + } + + } + { + p.SetState(8609) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8611) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1057, p.GetParserRuleContext()) == 1 { + { + p.SetState(8610) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8613) + p.Object_name() + } + p.SetState(8615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(8614) + p.Copy_grants() + } + + } + { + p.SetState(8617) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8618) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8619) + p.Object_name() + } + p.SetState(8621) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAT_KEYWORD || _la == SnowflakeParserBEFORE { + { + p.SetState(8620) + p.Stream_time() + } + + } + p.SetState(8624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPPEND_ONLY { + { + p.SetState(8623) + p.Append_only() + } + + } + p.SetState(8627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSHOW_INITIAL_ROWS { + { + p.SetState(8626) + p.Show_initial_rows() + } + + } + p.SetState(8630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8629) + p.Comment_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 +} + +// ITemporaryContext is an interface to support dynamic dispatch. +type ITemporaryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMP() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + + // IsTemporaryContext differentiates from other interfaces. + IsTemporaryContext() +} + +type TemporaryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTemporaryContext() *TemporaryContext { + var p = new(TemporaryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_temporary + return p +} + +func InitEmptyTemporaryContext(p *TemporaryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_temporary +} + +func (*TemporaryContext) IsTemporaryContext() {} + +func NewTemporaryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TemporaryContext { + var p = new(TemporaryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_temporary + + return p +} + +func (s *TemporaryContext) GetParser() antlr.Parser { return s.parser } + +func (s *TemporaryContext) TEMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEMP, 0) +} + +func (s *TemporaryContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEMPORARY, 0) +} + +func (s *TemporaryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TemporaryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TemporaryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTemporary(s) + } +} + +func (s *TemporaryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTemporary(s) + } +} + +func (s *TemporaryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTemporary(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Temporary() (localctx ITemporaryContext) { + localctx = NewTemporaryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 484, SnowflakeParserRULE_temporary) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8634) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserTEMP || _la == SnowflakeParserTEMPORARY) { + 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 +} + +// ITable_typeContext is an interface to support dynamic dispatch. +type ITable_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Temporary() ITemporaryContext + VOLATILE() antlr.TerminalNode + LOCAL() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + TRANSIENT() antlr.TerminalNode + + // IsTable_typeContext differentiates from other interfaces. + IsTable_typeContext() +} + +type Table_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_typeContext() *Table_typeContext { + var p = new(Table_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_type + return p +} + +func InitEmptyTable_typeContext(p *Table_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_type +} + +func (*Table_typeContext) IsTable_typeContext() {} + +func NewTable_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_typeContext { + var p = new(Table_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_table_type + + return p +} + +func (s *Table_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_typeContext) Temporary() ITemporaryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemporaryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemporaryContext) +} + +func (s *Table_typeContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVOLATILE, 0) +} + +func (s *Table_typeContext) LOCAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCAL, 0) +} + +func (s *Table_typeContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGLOBAL, 0) +} + +func (s *Table_typeContext) TRANSIENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSIENT, 0) +} + +func (s *Table_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTable_type(s) + } +} + +func (s *Table_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTable_type(s) + } +} + +func (s *Table_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTable_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Table_type() (localctx ITable_typeContext) { + localctx = NewTable_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 486, SnowflakeParserRULE_table_type) + var _la int + + p.SetState(8644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserGLOBAL, SnowflakeParserLOCAL, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserVOLATILE: + p.EnterOuterAlt(localctx, 1) + p.SetState(8641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserGLOBAL, SnowflakeParserLOCAL, SnowflakeParserTEMP, SnowflakeParserTEMPORARY: + p.SetState(8637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserGLOBAL || _la == SnowflakeParserLOCAL { + { + p.SetState(8636) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserGLOBAL || _la == SnowflakeParserLOCAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(8639) + p.Temporary() + } + + case SnowflakeParserVOLATILE: + { + p.SetState(8640) + p.Match(SnowflakeParserVOLATILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case SnowflakeParserTRANSIENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8643) + p.Match(SnowflakeParserTRANSIENT) + 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 +} + +// IWith_tagsContext is an interface to support dynamic dispatch. +type IWith_tagsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TAG() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllTag_decl() []ITag_declContext + Tag_decl(i int) ITag_declContext + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWith_tagsContext differentiates from other interfaces. + IsWith_tagsContext() +} + +type With_tagsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_tagsContext() *With_tagsContext { + var p = new(With_tagsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_with_tags + return p +} + +func InitEmptyWith_tagsContext(p *With_tagsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_with_tags +} + +func (*With_tagsContext) IsWith_tagsContext() {} + +func NewWith_tagsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_tagsContext { + var p = new(With_tagsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_with_tags + + return p +} + +func (s *With_tagsContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_tagsContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *With_tagsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *With_tagsContext) AllTag_decl() []ITag_declContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITag_declContext); ok { + len++ + } + } + + tst := make([]ITag_declContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITag_declContext); ok { + tst[i] = t.(ITag_declContext) + i++ + } + } + + return tst +} + +func (s *With_tagsContext) Tag_decl(i int) ITag_declContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITag_declContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITag_declContext) +} + +func (s *With_tagsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *With_tagsContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *With_tagsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *With_tagsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *With_tagsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_tagsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_tagsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterWith_tags(s) + } +} + +func (s *With_tagsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitWith_tags(s) + } +} + +func (s *With_tagsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitWith_tags(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) With_tags() (localctx IWith_tagsContext) { + localctx = NewWith_tagsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 488, SnowflakeParserRULE_with_tags) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(8646) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8649) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8650) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8651) + p.Tag_decl() + } + p.SetState(8656) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(8652) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8653) + p.Tag_decl() + } + + p.SetState(8658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8659) + p.Match(SnowflakeParserRR_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 +} + +// IWith_row_access_policyContext is an interface to support dynamic dispatch. +type IWith_row_access_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + ON() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RR_BRACKET() antlr.TerminalNode + WITH() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWith_row_access_policyContext differentiates from other interfaces. + IsWith_row_access_policyContext() +} + +type With_row_access_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_row_access_policyContext() *With_row_access_policyContext { + var p = new(With_row_access_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_with_row_access_policy + return p +} + +func InitEmptyWith_row_access_policyContext(p *With_row_access_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_with_row_access_policy +} + +func (*With_row_access_policyContext) IsWith_row_access_policyContext() {} + +func NewWith_row_access_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_row_access_policyContext { + var p = new(With_row_access_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_with_row_access_policy + + return p +} + +func (s *With_row_access_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_row_access_policyContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *With_row_access_policyContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *With_row_access_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *With_row_access_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *With_row_access_policyContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *With_row_access_policyContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *With_row_access_policyContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *With_row_access_policyContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *With_row_access_policyContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *With_row_access_policyContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *With_row_access_policyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *With_row_access_policyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *With_row_access_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_row_access_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_row_access_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterWith_row_access_policy(s) + } +} + +func (s *With_row_access_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitWith_row_access_policy(s) + } +} + +func (s *With_row_access_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitWith_row_access_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) With_row_access_policy() (localctx IWith_row_access_policyContext) { + localctx = NewWith_row_access_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 490, SnowflakeParserRULE_with_row_access_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(8661) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8664) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8665) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8666) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8667) + p.Id_() + } + { + p.SetState(8668) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8669) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8670) + p.Column_name() + } + p.SetState(8675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(8671) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8672) + p.Column_name() + } + + p.SetState(8677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8678) + p.Match(SnowflakeParserRR_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 +} + +// ICluster_byContext is an interface to support dynamic dispatch. +type ICluster_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTER() antlr.TerminalNode + BY() antlr.TerminalNode + Expr_list_in_parentheses() IExpr_list_in_parenthesesContext + + // IsCluster_byContext differentiates from other interfaces. + IsCluster_byContext() +} + +type Cluster_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_byContext() *Cluster_byContext { + var p = new(Cluster_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cluster_by + return p +} + +func InitEmptyCluster_byContext(p *Cluster_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cluster_by +} + +func (*Cluster_byContext) IsCluster_byContext() {} + +func NewCluster_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_byContext { + var p = new(Cluster_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_cluster_by + + return p +} + +func (s *Cluster_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_byContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTER, 0) +} + +func (s *Cluster_byContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Cluster_byContext) Expr_list_in_parentheses() IExpr_list_in_parenthesesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_list_in_parenthesesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_list_in_parenthesesContext) +} + +func (s *Cluster_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCluster_by(s) + } +} + +func (s *Cluster_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCluster_by(s) + } +} + +func (s *Cluster_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCluster_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Cluster_by() (localctx ICluster_byContext) { + localctx = NewCluster_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 492, SnowflakeParserRULE_cluster_by) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8680) + p.Match(SnowflakeParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8681) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8682) + p.Expr_list_in_parentheses() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IChange_trackingContext is an interface to support dynamic dispatch. +type IChange_trackingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHANGE_TRACKING() antlr.TerminalNode + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + + // IsChange_trackingContext differentiates from other interfaces. + IsChange_trackingContext() +} + +type Change_trackingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChange_trackingContext() *Change_trackingContext { + var p = new(Change_trackingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_change_tracking + return p +} + +func InitEmptyChange_trackingContext(p *Change_trackingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_change_tracking +} + +func (*Change_trackingContext) IsChange_trackingContext() {} + +func NewChange_trackingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Change_trackingContext { + var p = new(Change_trackingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_change_tracking + + return p +} + +func (s *Change_trackingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Change_trackingContext) CHANGE_TRACKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHANGE_TRACKING, 0) +} + +func (s *Change_trackingContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Change_trackingContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Change_trackingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Change_trackingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Change_trackingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterChange_tracking(s) + } +} + +func (s *Change_trackingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitChange_tracking(s) + } +} + +func (s *Change_trackingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitChange_tracking(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Change_tracking() (localctx IChange_trackingContext) { + localctx = NewChange_trackingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 494, SnowflakeParserRULE_change_tracking) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8684) + p.Match(SnowflakeParserCHANGE_TRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8685) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8686) + p.True_false() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_masking_policyContext is an interface to support dynamic dispatch. +type IWith_masking_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + WITH() antlr.TerminalNode + USING() antlr.TerminalNode + Column_list_in_parentheses() IColumn_list_in_parenthesesContext + + // IsWith_masking_policyContext differentiates from other interfaces. + IsWith_masking_policyContext() +} + +type With_masking_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_masking_policyContext() *With_masking_policyContext { + var p = new(With_masking_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_with_masking_policy + return p +} + +func InitEmptyWith_masking_policyContext(p *With_masking_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_with_masking_policy +} + +func (*With_masking_policyContext) IsWith_masking_policyContext() {} + +func NewWith_masking_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_masking_policyContext { + var p = new(With_masking_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_with_masking_policy + + return p +} + +func (s *With_masking_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_masking_policyContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *With_masking_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *With_masking_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *With_masking_policyContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *With_masking_policyContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *With_masking_policyContext) Column_list_in_parentheses() IColumn_list_in_parenthesesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_list_in_parenthesesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_list_in_parenthesesContext) +} + +func (s *With_masking_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_masking_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_masking_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterWith_masking_policy(s) + } +} + +func (s *With_masking_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitWith_masking_policy(s) + } +} + +func (s *With_masking_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitWith_masking_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) With_masking_policy() (localctx IWith_masking_policyContext) { + localctx = NewWith_masking_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, SnowflakeParserRULE_with_masking_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(8688) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8691) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8692) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8693) + p.Id_() + } + p.SetState(8696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSING { + { + p.SetState(8694) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8695) + p.Column_list_in_parentheses() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollateContext is an interface to support dynamic dispatch. +type ICollateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLLATE() antlr.TerminalNode + String_() IStringContext + + // IsCollateContext differentiates from other interfaces. + IsCollateContext() +} + +type CollateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollateContext() *CollateContext { + var p = new(CollateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_collate + return p +} + +func InitEmptyCollateContext(p *CollateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_collate +} + +func (*CollateContext) IsCollateContext() {} + +func NewCollateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollateContext { + var p = new(CollateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_collate + + return p +} + +func (s *CollateContext) GetParser() antlr.Parser { return s.parser } + +func (s *CollateContext) COLLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLLATE, 0) +} + +func (s *CollateContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *CollateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CollateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CollateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCollate(s) + } +} + +func (s *CollateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCollate(s) + } +} + +func (s *CollateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCollate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Collate() (localctx ICollateContext) { + localctx = NewCollateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, SnowflakeParserRULE_collate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8698) + p.Match(SnowflakeParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8699) + p.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 +} + +// INot_nullContext is an interface to support dynamic dispatch. +type INot_nullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsNot_nullContext differentiates from other interfaces. + IsNot_nullContext() +} + +type Not_nullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNot_nullContext() *Not_nullContext { + var p = new(Not_nullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_not_null + return p +} + +func InitEmptyNot_nullContext(p *Not_nullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_not_null +} + +func (*Not_nullContext) IsNot_nullContext() {} + +func NewNot_nullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Not_nullContext { + var p = new(Not_nullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_not_null + + return p +} + +func (s *Not_nullContext) GetParser() antlr.Parser { return s.parser } + +func (s *Not_nullContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *Not_nullContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Not_nullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Not_nullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Not_nullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterNot_null(s) + } +} + +func (s *Not_nullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitNot_null(s) + } +} + +func (s *Not_nullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitNot_null(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Not_null() (localctx INot_nullContext) { + localctx = NewNot_nullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, SnowflakeParserRULE_not_null) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8701) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8702) + p.Match(SnowflakeParserNULL_) + 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 +} + +// IDefault_valueContext is an interface to support dynamic dispatch. +type IDefault_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + Expr() IExprContext + AUTOINCREMENT() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + COMMA() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Start_with() IStart_withContext + Increment_by() IIncrement_byContext + + // IsDefault_valueContext differentiates from other interfaces. + IsDefault_valueContext() +} + +type Default_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_valueContext() *Default_valueContext { + var p = new(Default_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_default_value + return p +} + +func InitEmptyDefault_valueContext(p *Default_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_default_value +} + +func (*Default_valueContext) IsDefault_valueContext() {} + +func NewDefault_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_valueContext { + var p = new(Default_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_default_value + + return p +} + +func (s *Default_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_valueContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT, 0) +} + +func (s *Default_valueContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Default_valueContext) AUTOINCREMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTOINCREMENT, 0) +} + +func (s *Default_valueContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIDENTITY, 0) +} + +func (s *Default_valueContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Default_valueContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Default_valueContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Default_valueContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Default_valueContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Default_valueContext) Start_with() IStart_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_withContext) +} + +func (s *Default_valueContext) Increment_by() IIncrement_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIncrement_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIncrement_byContext) +} + +func (s *Default_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDefault_value(s) + } +} + +func (s *Default_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDefault_value(s) + } +} + +func (s *Default_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDefault_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Default_value() (localctx IDefault_valueContext) { + localctx = NewDefault_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, SnowflakeParserRULE_default_value) + var _la int + + p.SetState(8720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDEFAULT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8704) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8705) + p.expr(0) + } + + case SnowflakeParserAUTOINCREMENT, SnowflakeParserIDENTITY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8706) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAUTOINCREMENT || _la == SnowflakeParserIDENTITY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8718) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1073, p.GetParserRuleContext()) == 1 { + { + p.SetState(8707) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8708) + p.Num() + } + { + p.SetState(8709) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8710) + p.Num() + } + { + p.SetState(8711) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1073, p.GetParserRuleContext()) == 2 { + { + p.SetState(8713) + p.Start_with() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1073, p.GetParserRuleContext()) == 3 { + { + p.SetState(8714) + p.Increment_by() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1073, p.GetParserRuleContext()) == 4 { + { + p.SetState(8715) + p.Start_with() + } + { + p.SetState(8716) + p.Increment_by() + } + + } 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 +} + +// IForeign_keyContext is an interface to support dynamic dispatch. +type IForeign_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOREIGN() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsForeign_keyContext differentiates from other interfaces. + IsForeign_keyContext() +} + +type Foreign_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_keyContext() *Foreign_keyContext { + var p = new(Foreign_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_foreign_key + return p +} + +func InitEmptyForeign_keyContext(p *Foreign_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_foreign_key +} + +func (*Foreign_keyContext) IsForeign_keyContext() {} + +func NewForeign_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_keyContext { + var p = new(Foreign_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_foreign_key + + return p +} + +func (s *Foreign_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_keyContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFOREIGN, 0) +} + +func (s *Foreign_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEY, 0) +} + +func (s *Foreign_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterForeign_key(s) + } +} + +func (s *Foreign_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitForeign_key(s) + } +} + +func (s *Foreign_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitForeign_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Foreign_key() (localctx IForeign_keyContext) { + localctx = NewForeign_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, SnowflakeParserRULE_foreign_key) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8722) + p.Match(SnowflakeParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8723) + p.Match(SnowflakeParserKEY) + 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 +} + +// IOut_of_line_constraintContext is an interface to support dynamic dispatch. +type IOut_of_line_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNIQUE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + Object_name() IObject_nameContext + CONSTRAINT() antlr.TerminalNode + Id_() IId_Context + Constraint_properties() IConstraint_propertiesContext + AllColumn_list_in_parentheses() []IColumn_list_in_parenthesesContext + Column_list_in_parentheses(i int) IColumn_list_in_parenthesesContext + Foreign_key() IForeign_keyContext + + // IsOut_of_line_constraintContext differentiates from other interfaces. + IsOut_of_line_constraintContext() +} + +type Out_of_line_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOut_of_line_constraintContext() *Out_of_line_constraintContext { + var p = new(Out_of_line_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_out_of_line_constraint + return p +} + +func InitEmptyOut_of_line_constraintContext(p *Out_of_line_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_out_of_line_constraint +} + +func (*Out_of_line_constraintContext) IsOut_of_line_constraintContext() {} + +func NewOut_of_line_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Out_of_line_constraintContext { + var p = new(Out_of_line_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_out_of_line_constraint + + return p +} + +func (s *Out_of_line_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Out_of_line_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNIQUE, 0) +} + +func (s *Out_of_line_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Out_of_line_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEY, 0) +} + +func (s *Out_of_line_constraintContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFERENCES, 0) +} + +func (s *Out_of_line_constraintContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Out_of_line_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONSTRAINT, 0) +} + +func (s *Out_of_line_constraintContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Out_of_line_constraintContext) Constraint_properties() IConstraint_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_propertiesContext) +} + +func (s *Out_of_line_constraintContext) AllColumn_list_in_parentheses() []IColumn_list_in_parenthesesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_list_in_parenthesesContext); ok { + len++ + } + } + + tst := make([]IColumn_list_in_parenthesesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_list_in_parenthesesContext); ok { + tst[i] = t.(IColumn_list_in_parenthesesContext) + i++ + } + } + + return tst +} + +func (s *Out_of_line_constraintContext) Column_list_in_parentheses(i int) IColumn_list_in_parenthesesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_list_in_parenthesesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_list_in_parenthesesContext) +} + +func (s *Out_of_line_constraintContext) Foreign_key() IForeign_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_keyContext) +} + +func (s *Out_of_line_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Out_of_line_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Out_of_line_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterOut_of_line_constraint(s) + } +} + +func (s *Out_of_line_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitOut_of_line_constraint(s) + } +} + +func (s *Out_of_line_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitOut_of_line_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Out_of_line_constraint() (localctx IOut_of_line_constraintContext) { + localctx = NewOut_of_line_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, SnowflakeParserRULE_out_of_line_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCONSTRAINT { + { + p.SetState(8725) + p.Match(SnowflakeParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8726) + p.Id_() + } + + } + p.SetState(8749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserUNIQUE: + { + p.SetState(8729) + p.Match(SnowflakeParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(8730) + p.Column_list_in_parentheses() + } + + } + + case SnowflakeParserPRIMARY: + { + p.SetState(8733) + p.Match(SnowflakeParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8734) + p.Match(SnowflakeParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(8735) + p.Column_list_in_parentheses() + } + + } + + case SnowflakeParserFOREIGN, SnowflakeParserREFERENCES, SnowflakeParserLR_BRACKET: + p.SetState(8739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFOREIGN { + { + p.SetState(8738) + p.Foreign_key() + } + + } + p.SetState(8742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(8741) + p.Column_list_in_parentheses() + } + + } + { + p.SetState(8744) + p.Match(SnowflakeParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8745) + p.Object_name() + } + p.SetState(8747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(8746) + p.Column_list_in_parentheses() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-226)) & ^0x3f) == 0 && ((int64(1)<<(_la-226))&8798240514113) != 0) || _la == SnowflakeParserINITIALLY || ((int64((_la-458)) & ^0x3f) == 0 && ((int64(1)<<(_la-458))&1166432303488958465) != 0) || _la == SnowflakeParserRELY || _la == SnowflakeParserUPDATE || _la == SnowflakeParserVALIDATE { + { + p.SetState(8751) + p.Constraint_properties() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFull_col_declContext is an interface to support dynamic dispatch. +type IFull_col_declContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Col_decl() ICol_declContext + AllCollate() []ICollateContext + Collate(i int) ICollateContext + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + AllDefault_value() []IDefault_valueContext + Default_value(i int) IDefault_valueContext + AllNull_not_null() []INull_not_nullContext + Null_not_null(i int) INull_not_nullContext + With_masking_policy() IWith_masking_policyContext + With_tags() IWith_tagsContext + COMMENT() antlr.TerminalNode + String_() IStringContext + + // IsFull_col_declContext differentiates from other interfaces. + IsFull_col_declContext() +} + +type Full_col_declContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFull_col_declContext() *Full_col_declContext { + var p = new(Full_col_declContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_full_col_decl + return p +} + +func InitEmptyFull_col_declContext(p *Full_col_declContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_full_col_decl +} + +func (*Full_col_declContext) IsFull_col_declContext() {} + +func NewFull_col_declContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_col_declContext { + var p = new(Full_col_declContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_full_col_decl + + return p +} + +func (s *Full_col_declContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_col_declContext) Col_decl() ICol_declContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICol_declContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICol_declContext) +} + +func (s *Full_col_declContext) AllCollate() []ICollateContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICollateContext); ok { + len++ + } + } + + tst := make([]ICollateContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICollateContext); ok { + tst[i] = t.(ICollateContext) + i++ + } + } + + return tst +} + +func (s *Full_col_declContext) Collate(i int) ICollateContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollateContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICollateContext) +} + +func (s *Full_col_declContext) AllInline_constraint() []IInline_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInline_constraintContext); ok { + len++ + } + } + + tst := make([]IInline_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInline_constraintContext); ok { + tst[i] = t.(IInline_constraintContext) + i++ + } + } + + return tst +} + +func (s *Full_col_declContext) Inline_constraint(i int) IInline_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInline_constraintContext) +} + +func (s *Full_col_declContext) AllDefault_value() []IDefault_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDefault_valueContext); ok { + len++ + } + } + + tst := make([]IDefault_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDefault_valueContext); ok { + tst[i] = t.(IDefault_valueContext) + i++ + } + } + + return tst +} + +func (s *Full_col_declContext) Default_value(i int) IDefault_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDefault_valueContext) +} + +func (s *Full_col_declContext) AllNull_not_null() []INull_not_nullContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INull_not_nullContext); ok { + len++ + } + } + + tst := make([]INull_not_nullContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INull_not_nullContext); ok { + tst[i] = t.(INull_not_nullContext) + i++ + } + } + + return tst +} + +func (s *Full_col_declContext) Null_not_null(i int) INull_not_nullContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_not_nullContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INull_not_nullContext) +} + +func (s *Full_col_declContext) With_masking_policy() IWith_masking_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_masking_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_masking_policyContext) +} + +func (s *Full_col_declContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Full_col_declContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Full_col_declContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Full_col_declContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_col_declContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_col_declContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFull_col_decl(s) + } +} + +func (s *Full_col_declContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFull_col_decl(s) + } +} + +func (s *Full_col_declContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFull_col_decl(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Full_col_decl() (localctx IFull_col_declContext) { + localctx = NewFull_col_declContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, SnowflakeParserRULE_full_col_decl) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8754) + p.Col_decl() + } + p.SetState(8761) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserAUTOINCREMENT || _la == SnowflakeParserCOLLATE || _la == SnowflakeParserCONSTRAINT || _la == SnowflakeParserDEFAULT || _la == SnowflakeParserFOREIGN || _la == SnowflakeParserIDENTITY || _la == SnowflakeParserNOT || _la == SnowflakeParserNULL_ || _la == SnowflakeParserPRIMARY || _la == SnowflakeParserREFERENCES || _la == SnowflakeParserUNIQUE { + p.SetState(8759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1083, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8755) + p.Collate() + } + + case 2: + { + p.SetState(8756) + p.Inline_constraint() + } + + case 3: + { + p.SetState(8757) + p.Default_value() + } + + case 4: + { + p.SetState(8758) + p.Null_not_null() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8765) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1085, p.GetParserRuleContext()) == 1 { + { + p.SetState(8764) + p.With_masking_policy() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(8767) + p.With_tags() + } + + } + p.SetState(8772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8770) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8771) + p.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 +} + +// IColumn_decl_itemContext is an interface to support dynamic dispatch. +type IColumn_decl_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Full_col_decl() IFull_col_declContext + Out_of_line_constraint() IOut_of_line_constraintContext + + // IsColumn_decl_itemContext differentiates from other interfaces. + IsColumn_decl_itemContext() +} + +type Column_decl_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_decl_itemContext() *Column_decl_itemContext { + var p = new(Column_decl_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_decl_item + return p +} + +func InitEmptyColumn_decl_itemContext(p *Column_decl_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_decl_item +} + +func (*Column_decl_itemContext) IsColumn_decl_itemContext() {} + +func NewColumn_decl_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_decl_itemContext { + var p = new(Column_decl_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_decl_item + + return p +} + +func (s *Column_decl_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_decl_itemContext) Full_col_decl() IFull_col_declContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_col_declContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_col_declContext) +} + +func (s *Column_decl_itemContext) Out_of_line_constraint() IOut_of_line_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Column_decl_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_decl_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_decl_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_decl_item(s) + } +} + +func (s *Column_decl_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_decl_item(s) + } +} + +func (s *Column_decl_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_decl_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_decl_item() (localctx IColumn_decl_itemContext) { + localctx = NewColumn_decl_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, SnowflakeParserRULE_column_decl_item) + p.SetState(8776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1088, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8774) + p.Full_col_decl() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8775) + p.Out_of_line_constraint() + } + + 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 +} + +// IColumn_decl_item_listContext is an interface to support dynamic dispatch. +type IColumn_decl_item_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_decl_item() []IColumn_decl_itemContext + Column_decl_item(i int) IColumn_decl_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_decl_item_listContext differentiates from other interfaces. + IsColumn_decl_item_listContext() +} + +type Column_decl_item_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_decl_item_listContext() *Column_decl_item_listContext { + var p = new(Column_decl_item_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_decl_item_list + return p +} + +func InitEmptyColumn_decl_item_listContext(p *Column_decl_item_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_decl_item_list +} + +func (*Column_decl_item_listContext) IsColumn_decl_item_listContext() {} + +func NewColumn_decl_item_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_decl_item_listContext { + var p = new(Column_decl_item_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_decl_item_list + + return p +} + +func (s *Column_decl_item_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_decl_item_listContext) AllColumn_decl_item() []IColumn_decl_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_decl_itemContext); ok { + len++ + } + } + + tst := make([]IColumn_decl_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_decl_itemContext); ok { + tst[i] = t.(IColumn_decl_itemContext) + i++ + } + } + + return tst +} + +func (s *Column_decl_item_listContext) Column_decl_item(i int) IColumn_decl_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_decl_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_decl_itemContext) +} + +func (s *Column_decl_item_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Column_decl_item_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Column_decl_item_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_decl_item_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_decl_item_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_decl_item_list(s) + } +} + +func (s *Column_decl_item_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_decl_item_list(s) + } +} + +func (s *Column_decl_item_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_decl_item_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_decl_item_list() (localctx IColumn_decl_item_listContext) { + localctx = NewColumn_decl_item_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, SnowflakeParserRULE_column_decl_item_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8778) + p.Column_decl_item() + } + p.SetState(8783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(8779) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8780) + p.Column_decl_item() + } + + p.SetState(8785) + 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_tableContext is an interface to support dynamic dispatch. +type ICreate_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Column_decl_item_list() IColumn_decl_item_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Object_name() IObject_nameContext + Or_replace() IOr_replaceContext + Table_type() ITable_typeContext + Cluster_by() ICluster_byContext + Stage_file_format() IStage_file_formatContext + STAGE_COPY_OPTIONS() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + Copy_options() ICopy_optionsContext + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + Change_tracking() IChange_trackingContext + Default_ddl_collation() IDefault_ddl_collationContext + Copy_grants() ICopy_grantsContext + With_row_access_policy() IWith_row_access_policyContext + With_tags() IWith_tagsContext + Comment_clause() IComment_clauseContext + If_not_exists() IIf_not_existsContext + + // IsCreate_tableContext differentiates from other interfaces. + IsCreate_tableContext() +} + +type Create_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_tableContext() *Create_tableContext { + var p = new(Create_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_table + return p +} + +func InitEmptyCreate_tableContext(p *Create_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_table +} + +func (*Create_tableContext) IsCreate_tableContext() {} + +func NewCreate_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tableContext { + var p = new(Create_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_table + + return p +} + +func (s *Create_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tableContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Create_tableContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Create_tableContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Create_tableContext) Column_decl_item_list() IColumn_decl_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_decl_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_decl_item_listContext) +} + +func (s *Create_tableContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Create_tableContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Create_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_tableContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_tableContext) Table_type() ITable_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_typeContext) +} + +func (s *Create_tableContext) Cluster_by() ICluster_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_byContext) +} + +func (s *Create_tableContext) Stage_file_format() IStage_file_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStage_file_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStage_file_formatContext) +} + +func (s *Create_tableContext) STAGE_COPY_OPTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE_COPY_OPTIONS, 0) +} + +func (s *Create_tableContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_tableContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_tableContext) 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 *Create_tableContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Create_tableContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Create_tableContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Create_tableContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Create_tableContext) Change_tracking() IChange_trackingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChange_trackingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChange_trackingContext) +} + +func (s *Create_tableContext) Default_ddl_collation() IDefault_ddl_collationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_ddl_collationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_ddl_collationContext) +} + +func (s *Create_tableContext) Copy_grants() ICopy_grantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_grantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_grantsContext) +} + +func (s *Create_tableContext) With_row_access_policy() IWith_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_row_access_policyContext) +} + +func (s *Create_tableContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Create_tableContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_tableContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_table(s) + } +} + +func (s *Create_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_table(s) + } +} + +func (s *Create_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_table() (localctx ICreate_tableContext) { + localctx = NewCreate_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, SnowflakeParserRULE_create_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8786) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8787) + p.Or_replace() + } + + } + p.SetState(8791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserGLOBAL || _la == SnowflakeParserLOCAL || ((int64((_la-893)) & ^0x3f) == 0 && ((int64(1)<<(_la-893))&8796093022211) != 0) || _la == SnowflakeParserVOLATILE { + { + p.SetState(8790) + p.Table_type() + } + + } + { + p.SetState(8793) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1094, p.GetParserRuleContext()) { + case 1: + p.SetState(8795) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1092, p.GetParserRuleContext()) == 1 { + { + p.SetState(8794) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8797) + p.Object_name() + } + + case 2: + { + p.SetState(8798) + p.Object_name() + } + p.SetState(8800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIF { + { + p.SetState(8799) + p.If_not_exists() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(8804) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8805) + p.Column_decl_item_list() + } + { + p.SetState(8806) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCLUSTER { + { + p.SetState(8807) + p.Cluster_by() + } + + } + p.SetState(8811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTAGE_FILE_FORMAT || _la == SnowflakeParserTYPE { + { + p.SetState(8810) + p.Stage_file_format() + } + + } + p.SetState(8819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTAGE_COPY_OPTIONS { + { + p.SetState(8813) + p.Match(SnowflakeParserSTAGE_COPY_OPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8814) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8815) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8816) + p.Copy_options() + } + { + p.SetState(8817) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDATA_RETENTION_TIME_IN_DAYS { + { + p.SetState(8821) + p.Match(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8822) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8823) + p.Num() + } + + } + p.SetState(8829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS { + { + p.SetState(8826) + p.Match(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8827) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8828) + p.Num() + } + + } + p.SetState(8832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCHANGE_TRACKING { + { + p.SetState(8831) + p.Change_tracking() + } + + } + p.SetState(8835) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDEFAULT_DDL_COLLATION_ { + { + p.SetState(8834) + p.Default_ddl_collation() + } + + } + p.SetState(8838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(8837) + p.Copy_grants() + } + + } + p.SetState(8841) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1103, p.GetParserRuleContext()) == 1 { + { + p.SetState(8840) + p.With_row_access_policy() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(8843) + p.With_tags() + } + + } + p.SetState(8847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8846) + p.Comment_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 +} + +// ICreate_table_as_selectContext is an interface to support dynamic dispatch. +type ICreate_table_as_selectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TABLE() antlr.TerminalNode + AS() antlr.TerminalNode + Select_statement() ISelect_statementContext + Object_name() IObject_nameContext + Or_replace() IOr_replaceContext + Table_type() ITable_typeContext + LR_BRACKET() antlr.TerminalNode + Column_decl_item_list() IColumn_decl_item_listContext + RR_BRACKET() antlr.TerminalNode + Cluster_by() ICluster_byContext + Copy_grants() ICopy_grantsContext + With_row_access_policy() IWith_row_access_policyContext + With_tags() IWith_tagsContext + Comment_clause() IComment_clauseContext + If_not_exists() IIf_not_existsContext + + // IsCreate_table_as_selectContext differentiates from other interfaces. + IsCreate_table_as_selectContext() +} + +type Create_table_as_selectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_table_as_selectContext() *Create_table_as_selectContext { + var p = new(Create_table_as_selectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_table_as_select + return p +} + +func InitEmptyCreate_table_as_selectContext(p *Create_table_as_selectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_table_as_select +} + +func (*Create_table_as_selectContext) IsCreate_table_as_selectContext() {} + +func NewCreate_table_as_selectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_table_as_selectContext { + var p = new(Create_table_as_selectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_table_as_select + + return p +} + +func (s *Create_table_as_selectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_table_as_selectContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_table_as_selectContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Create_table_as_selectContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_table_as_selectContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Create_table_as_selectContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_table_as_selectContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_table_as_selectContext) Table_type() ITable_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_typeContext) +} + +func (s *Create_table_as_selectContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Create_table_as_selectContext) Column_decl_item_list() IColumn_decl_item_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_decl_item_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_decl_item_listContext) +} + +func (s *Create_table_as_selectContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Create_table_as_selectContext) Cluster_by() ICluster_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_byContext) +} + +func (s *Create_table_as_selectContext) Copy_grants() ICopy_grantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_grantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_grantsContext) +} + +func (s *Create_table_as_selectContext) With_row_access_policy() IWith_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_row_access_policyContext) +} + +func (s *Create_table_as_selectContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Create_table_as_selectContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_table_as_selectContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_table_as_selectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_table_as_selectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_table_as_selectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_table_as_select(s) + } +} + +func (s *Create_table_as_selectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_table_as_select(s) + } +} + +func (s *Create_table_as_selectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_table_as_select(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_table_as_select() (localctx ICreate_table_as_selectContext) { + localctx = NewCreate_table_as_selectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, SnowflakeParserRULE_create_table_as_select) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8849) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8851) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8850) + p.Or_replace() + } + + } + p.SetState(8854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserGLOBAL || _la == SnowflakeParserLOCAL || ((int64((_la-893)) & ^0x3f) == 0 && ((int64(1)<<(_la-893))&8796093022211) != 0) || _la == SnowflakeParserVOLATILE { + { + p.SetState(8853) + p.Table_type() + } + + } + { + p.SetState(8856) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1110, p.GetParserRuleContext()) { + case 1: + p.SetState(8858) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1108, p.GetParserRuleContext()) == 1 { + { + p.SetState(8857) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8860) + p.Object_name() + } + + case 2: + { + p.SetState(8861) + p.Object_name() + } + p.SetState(8863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIF { + { + p.SetState(8862) + p.If_not_exists() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(8867) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8868) + p.Column_decl_item_list() + } + { + p.SetState(8869) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCLUSTER { + { + p.SetState(8873) + p.Cluster_by() + } + + } + p.SetState(8877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(8876) + p.Copy_grants() + } + + } + p.SetState(8880) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1114, p.GetParserRuleContext()) == 1 { + { + p.SetState(8879) + p.With_row_access_policy() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(8882) + p.With_tags() + } + + } + p.SetState(8886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8885) + p.Comment_clause() + } + + } + { + p.SetState(8888) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8889) + p.Select_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_tagContext is an interface to support dynamic dispatch. +type ICreate_tagContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TAG() antlr.TerminalNode + Id_() IId_Context + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + Comment_clause() IComment_clauseContext + ALLOWED_VALUES() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_tagContext differentiates from other interfaces. + IsCreate_tagContext() +} + +type Create_tagContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_tagContext() *Create_tagContext { + var p = new(Create_tagContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_tag + return p +} + +func InitEmptyCreate_tagContext(p *Create_tagContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_tag +} + +func (*Create_tagContext) IsCreate_tagContext() {} + +func NewCreate_tagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tagContext { + var p = new(Create_tagContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_tag + + return p +} + +func (s *Create_tagContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tagContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_tagContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Create_tagContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_tagContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_tagContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_tagContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_tagContext) ALLOWED_VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_VALUES, 0) +} + +func (s *Create_tagContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_tagContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_tagContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_tagContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_tagContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_tagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_tagContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_tag(s) + } +} + +func (s *Create_tagContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_tag(s) + } +} + +func (s *Create_tagContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_tag(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_tag() (localctx ICreate_tagContext) { + localctx = NewCreate_tagContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, SnowflakeParserRULE_create_tag) + var _la int + + p.SetState(8923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1124, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8891) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8892) + p.Or_replace() + } + + } + { + p.SetState(8895) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8897) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1118, p.GetParserRuleContext()) == 1 { + { + p.SetState(8896) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8899) + p.Id_() + } + p.SetState(8901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8900) + p.Comment_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8903) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8904) + p.Or_replace() + } + + } + { + p.SetState(8907) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8909) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1121, p.GetParserRuleContext()) == 1 { + { + p.SetState(8908) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8911) + p.Id_() + } + p.SetState(8921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOWED_VALUES { + { + p.SetState(8912) + p.Match(SnowflakeParserALLOWED_VALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8913) + p.String_() + } + p.SetState(8918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(8914) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8915) + p.String_() + } + + p.SetState(8920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + 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 +} + +// ISession_parameterContext is an interface to support dynamic dispatch. +type ISession_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT_DETACHED_QUERY() antlr.TerminalNode + ALLOW_CLIENT_MFA_CACHING() antlr.TerminalNode + ALLOW_ID_TOKEN() antlr.TerminalNode + AUTOCOMMIT() antlr.TerminalNode + AUTOCOMMIT_API_SUPPORTED() antlr.TerminalNode + BINARY_INPUT_FORMAT() antlr.TerminalNode + BINARY_OUTPUT_FORMAT() antlr.TerminalNode + CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS() antlr.TerminalNode + CLIENT_ENCRYPTION_KEY_SIZE() antlr.TerminalNode + CLIENT_MEMORY_LIMIT() antlr.TerminalNode + CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX() antlr.TerminalNode + CLIENT_METADATA_USE_SESSION_DATABASE() antlr.TerminalNode + CLIENT_PREFETCH_THREADS() antlr.TerminalNode + CLIENT_RESULT_CHUNK_SIZE() antlr.TerminalNode + CLIENT_RESULT_COLUMN_CASE_INSENSITIVE() antlr.TerminalNode + CLIENT_SESSION_KEEP_ALIVE() antlr.TerminalNode + CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY() antlr.TerminalNode + CLIENT_TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + DATE_INPUT_FORMAT() antlr.TerminalNode + DATE_OUTPUT_FORMAT() antlr.TerminalNode + DEFAULT_DDL_COLLATION_() antlr.TerminalNode + ENABLE_INTERNAL_STAGES_PRIVATELINK() antlr.TerminalNode + ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION() antlr.TerminalNode + ENFORCE_SESSION_POLICY() antlr.TerminalNode + ERROR_ON_NONDETERMINISTIC_MERGE() antlr.TerminalNode + ERROR_ON_NONDETERMINISTIC_UPDATE() antlr.TerminalNode + EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST() antlr.TerminalNode + GEOGRAPHY_OUTPUT_FORMAT() antlr.TerminalNode + GEOMETRY_OUTPUT_FORMAT() antlr.TerminalNode + INITIAL_REPLICATION_SIZE_LIMIT_IN_TB() antlr.TerminalNode + JDBC_TREAT_DECIMAL_AS_INT() antlr.TerminalNode + JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC() antlr.TerminalNode + JDBC_USE_SESSION_TIMEZONE() antlr.TerminalNode + JSON_INDENT() antlr.TerminalNode + JS_TREAT_INTEGER_AS_BIGINT() antlr.TerminalNode + LOCK_TIMEOUT() antlr.TerminalNode + MAX_CONCURRENCY_LEVEL() antlr.TerminalNode + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + MULTI_STATEMENT_COUNT() antlr.TerminalNode + MIN_DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + NETWORK_POLICY() antlr.TerminalNode + SHARE_RESTRICTIONS() antlr.TerminalNode + PERIODIC_DATA_REKEYING() antlr.TerminalNode + PIPE_EXECUTION_PAUSED() antlr.TerminalNode + PREVENT_UNLOAD_TO_INLINE_URL() antlr.TerminalNode + PREVENT_UNLOAD_TO_INTERNAL_STAGES() antlr.TerminalNode + QUERY_TAG() antlr.TerminalNode + QUOTED_IDENTIFIERS_IGNORE_CASE() antlr.TerminalNode + REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION() antlr.TerminalNode + REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION() antlr.TerminalNode + ROWS_PER_RESULTSET() antlr.TerminalNode + SAML_IDENTITY_PROVIDER() antlr.TerminalNode + SIMULATED_DATA_SHARING_CONSUMER() antlr.TerminalNode + SSO_LOGIN_PAGE() antlr.TerminalNode + STATEMENT_QUEUED_TIMEOUT_IN_SECONDS() antlr.TerminalNode + STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode + STRICT_JSON_OUTPUT() antlr.TerminalNode + SUSPEND_TASK_AFTER_NUM_FAILURES() antlr.TerminalNode + TIMESTAMP_DAY_IS_ALWAYS_24H() antlr.TerminalNode + TIMESTAMP_INPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_LTZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_NTZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode + TIMESTAMP_TZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + TIME_INPUT_FORMAT() antlr.TerminalNode + TIME_OUTPUT_FORMAT() antlr.TerminalNode + TRANSACTION_ABORT_ON_ERROR() antlr.TerminalNode + TRANSACTION_DEFAULT_ISOLATION_LEVEL() antlr.TerminalNode + TWO_DIGIT_CENTURY_START() antlr.TerminalNode + UNSUPPORTED_DDL_ACTION() antlr.TerminalNode + USE_CACHED_RESULT() antlr.TerminalNode + USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE() antlr.TerminalNode + USER_TASK_TIMEOUT_MS() antlr.TerminalNode + WEEK_OF_YEAR_POLICY() antlr.TerminalNode + WEEK_START() antlr.TerminalNode + + // IsSession_parameterContext differentiates from other interfaces. + IsSession_parameterContext() +} + +type Session_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySession_parameterContext() *Session_parameterContext { + var p = new(Session_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_parameter + return p +} + +func InitEmptySession_parameterContext(p *Session_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_parameter +} + +func (*Session_parameterContext) IsSession_parameterContext() {} + +func NewSession_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Session_parameterContext { + var p = new(Session_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_session_parameter + + return p +} + +func (s *Session_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Session_parameterContext) ABORT_DETACHED_QUERY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT_DETACHED_QUERY, 0) +} + +func (s *Session_parameterContext) ALLOW_CLIENT_MFA_CACHING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_CLIENT_MFA_CACHING, 0) +} + +func (s *Session_parameterContext) ALLOW_ID_TOKEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_ID_TOKEN, 0) +} + +func (s *Session_parameterContext) AUTOCOMMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTOCOMMIT, 0) +} + +func (s *Session_parameterContext) AUTOCOMMIT_API_SUPPORTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTOCOMMIT_API_SUPPORTED, 0) +} + +func (s *Session_parameterContext) BINARY_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_INPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) BINARY_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, 0) +} + +func (s *Session_parameterContext) CLIENT_ENCRYPTION_KEY_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, 0) +} + +func (s *Session_parameterContext) CLIENT_MEMORY_LIMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_MEMORY_LIMIT, 0) +} + +func (s *Session_parameterContext) CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, 0) +} + +func (s *Session_parameterContext) CLIENT_METADATA_USE_SESSION_DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, 0) +} + +func (s *Session_parameterContext) CLIENT_PREFETCH_THREADS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_PREFETCH_THREADS, 0) +} + +func (s *Session_parameterContext) CLIENT_RESULT_CHUNK_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, 0) +} + +func (s *Session_parameterContext) CLIENT_RESULT_COLUMN_CASE_INSENSITIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, 0) +} + +func (s *Session_parameterContext) CLIENT_SESSION_KEEP_ALIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, 0) +} + +func (s *Session_parameterContext) CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, 0) +} + +func (s *Session_parameterContext) CLIENT_TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, 0) +} + +func (s *Session_parameterContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Session_parameterContext) DATE_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_INPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) DATE_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) DEFAULT_DDL_COLLATION_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_DDL_COLLATION_, 0) +} + +func (s *Session_parameterContext) ENABLE_INTERNAL_STAGES_PRIVATELINK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, 0) +} + +func (s *Session_parameterContext) ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, 0) +} + +func (s *Session_parameterContext) ENFORCE_SESSION_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENFORCE_SESSION_POLICY, 0) +} + +func (s *Session_parameterContext) ERROR_ON_NONDETERMINISTIC_MERGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, 0) +} + +func (s *Session_parameterContext) ERROR_ON_NONDETERMINISTIC_UPDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, 0) +} + +func (s *Session_parameterContext) EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, 0) +} + +func (s *Session_parameterContext) GEOGRAPHY_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) GEOMETRY_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEOMETRY_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) INITIAL_REPLICATION_SIZE_LIMIT_IN_TB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, 0) +} + +func (s *Session_parameterContext) JDBC_TREAT_DECIMAL_AS_INT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, 0) +} + +func (s *Session_parameterContext) JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, 0) +} + +func (s *Session_parameterContext) JDBC_USE_SESSION_TIMEZONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJDBC_USE_SESSION_TIMEZONE, 0) +} + +func (s *Session_parameterContext) JSON_INDENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON_INDENT, 0) +} + +func (s *Session_parameterContext) JS_TREAT_INTEGER_AS_BIGINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, 0) +} + +func (s *Session_parameterContext) LOCK_TIMEOUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCK_TIMEOUT, 0) +} + +func (s *Session_parameterContext) MAX_CONCURRENCY_LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_CONCURRENCY_LEVEL, 0) +} + +func (s *Session_parameterContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Session_parameterContext) MULTI_STATEMENT_COUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMULTI_STATEMENT_COUNT, 0) +} + +func (s *Session_parameterContext) MIN_DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Session_parameterContext) NETWORK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK_POLICY, 0) +} + +func (s *Session_parameterContext) SHARE_RESTRICTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE_RESTRICTIONS, 0) +} + +func (s *Session_parameterContext) PERIODIC_DATA_REKEYING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERIODIC_DATA_REKEYING, 0) +} + +func (s *Session_parameterContext) PIPE_EXECUTION_PAUSED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE_EXECUTION_PAUSED, 0) +} + +func (s *Session_parameterContext) PREVENT_UNLOAD_TO_INLINE_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, 0) +} + +func (s *Session_parameterContext) PREVENT_UNLOAD_TO_INTERNAL_STAGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, 0) +} + +func (s *Session_parameterContext) QUERY_TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERY_TAG, 0) +} + +func (s *Session_parameterContext) QUOTED_IDENTIFIERS_IGNORE_CASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, 0) +} + +func (s *Session_parameterContext) REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, 0) +} + +func (s *Session_parameterContext) REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, 0) +} + +func (s *Session_parameterContext) ROWS_PER_RESULTSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWS_PER_RESULTSET, 0) +} + +func (s *Session_parameterContext) SAML_IDENTITY_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML_IDENTITY_PROVIDER, 0) +} + +func (s *Session_parameterContext) SIMULATED_DATA_SHARING_CONSUMER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, 0) +} + +func (s *Session_parameterContext) SSO_LOGIN_PAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSSO_LOGIN_PAGE, 0) +} + +func (s *Session_parameterContext) STATEMENT_QUEUED_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Session_parameterContext) STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Session_parameterContext) STRICT_JSON_OUTPUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRICT_JSON_OUTPUT, 0) +} + +func (s *Session_parameterContext) SUSPEND_TASK_AFTER_NUM_FAILURES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, 0) +} + +func (s *Session_parameterContext) TIMESTAMP_DAY_IS_ALWAYS_24H() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_DAY_IS_ALWAYS_24H, 0) +} + +func (s *Session_parameterContext) TIMESTAMP_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_INPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) TIMESTAMP_LTZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) TIMESTAMP_NTZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) TIMESTAMP_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_TYPE_MAPPING, 0) +} + +func (s *Session_parameterContext) TIMESTAMP_TZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEZONE, 0) +} + +func (s *Session_parameterContext) TIME_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME_INPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) TIME_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME_OUTPUT_FORMAT, 0) +} + +func (s *Session_parameterContext) TRANSACTION_ABORT_ON_ERROR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTION_ABORT_ON_ERROR, 0) +} + +func (s *Session_parameterContext) TRANSACTION_DEFAULT_ISOLATION_LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, 0) +} + +func (s *Session_parameterContext) TWO_DIGIT_CENTURY_START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTWO_DIGIT_CENTURY_START, 0) +} + +func (s *Session_parameterContext) UNSUPPORTED_DDL_ACTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSUPPORTED_DDL_ACTION, 0) +} + +func (s *Session_parameterContext) USE_CACHED_RESULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE_CACHED_RESULT, 0) +} + +func (s *Session_parameterContext) USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, 0) +} + +func (s *Session_parameterContext) USER_TASK_TIMEOUT_MS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_TASK_TIMEOUT_MS, 0) +} + +func (s *Session_parameterContext) WEEK_OF_YEAR_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWEEK_OF_YEAR_POLICY, 0) +} + +func (s *Session_parameterContext) WEEK_START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWEEK_START, 0) +} + +func (s *Session_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Session_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Session_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSession_parameter(s) + } +} + +func (s *Session_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSession_parameter(s) + } +} + +func (s *Session_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSession_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Session_parameter() (localctx ISession_parameterContext) { + localctx = NewSession_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, SnowflakeParserRULE_session_parameter) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8925) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-4)) & ^0x3f) == 0 && ((int64(1)<<(_la-4))&3458764515028500481) != 0) || ((int64((_la-100)) & ^0x3f) == 0 && ((int64(1)<<(_la-100))&562675075514371) != 0) || ((int64((_la-209)) & ^0x3f) == 0 && ((int64(1)<<(_la-209))&4631952216750563521) != 0) || ((int64((_la-276)) & ^0x3f) == 0 && ((int64(1)<<(_la-276))&131075) != 0) || ((int64((_la-341)) & ^0x3f) == 0 && ((int64(1)<<(_la-341))&-4611615649683210237) != 0) || ((int64((_la-405)) & ^0x3f) == 0 && ((int64(1)<<(_la-405))&6917529165080035377) != 0) || ((int64((_la-480)) & ^0x3f) == 0 && ((int64(1)<<(_la-480))&131329) != 0) || ((int64((_la-596)) & ^0x3f) == 0 && ((int64(1)<<(_la-596))&1407374886699137) != 0) || ((int64((_la-691)) & ^0x3f) == 0 && ((int64(1)<<(_la-691))&1152921642045800451) != 0) || ((int64((_la-789)) & ^0x3f) == 0 && ((int64(1)<<(_la-789))&211110527500801) != 0) || ((int64((_la-860)) & ^0x3f) == 0 && ((int64(1)<<(_la-860))&3799525157500887041) != 0) || ((int64((_la-932)) & ^0x3f) == 0 && ((int64(1)<<(_la-932))&792642330511278083) != 0) || _la == SnowflakeParserWEEK_OF_YEAR_POLICY || _la == SnowflakeParserWEEK_START) { + 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 +} + +// ISession_parameter_listContext is an interface to support dynamic dispatch. +type ISession_parameter_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSession_parameter() []ISession_parameterContext + Session_parameter(i int) ISession_parameterContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSession_parameter_listContext differentiates from other interfaces. + IsSession_parameter_listContext() +} + +type Session_parameter_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySession_parameter_listContext() *Session_parameter_listContext { + var p = new(Session_parameter_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_parameter_list + return p +} + +func InitEmptySession_parameter_listContext(p *Session_parameter_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_parameter_list +} + +func (*Session_parameter_listContext) IsSession_parameter_listContext() {} + +func NewSession_parameter_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Session_parameter_listContext { + var p = new(Session_parameter_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_session_parameter_list + + return p +} + +func (s *Session_parameter_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Session_parameter_listContext) AllSession_parameter() []ISession_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISession_parameterContext); ok { + len++ + } + } + + tst := make([]ISession_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISession_parameterContext); ok { + tst[i] = t.(ISession_parameterContext) + i++ + } + } + + return tst +} + +func (s *Session_parameter_listContext) Session_parameter(i int) ISession_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISession_parameterContext) +} + +func (s *Session_parameter_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Session_parameter_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Session_parameter_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Session_parameter_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Session_parameter_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSession_parameter_list(s) + } +} + +func (s *Session_parameter_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSession_parameter_list(s) + } +} + +func (s *Session_parameter_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSession_parameter_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Session_parameter_list() (localctx ISession_parameter_listContext) { + localctx = NewSession_parameter_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, SnowflakeParserRULE_session_parameter_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8927) + p.Session_parameter() + } + p.SetState(8932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(8928) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8929) + p.Session_parameter() + } + + p.SetState(8934) + 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 +} + +// ISession_parameter_init_listContext is an interface to support dynamic dispatch. +type ISession_parameter_init_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSession_parameter_init() []ISession_parameter_initContext + Session_parameter_init(i int) ISession_parameter_initContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSession_parameter_init_listContext differentiates from other interfaces. + IsSession_parameter_init_listContext() +} + +type Session_parameter_init_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySession_parameter_init_listContext() *Session_parameter_init_listContext { + var p = new(Session_parameter_init_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_parameter_init_list + return p +} + +func InitEmptySession_parameter_init_listContext(p *Session_parameter_init_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_parameter_init_list +} + +func (*Session_parameter_init_listContext) IsSession_parameter_init_listContext() {} + +func NewSession_parameter_init_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Session_parameter_init_listContext { + var p = new(Session_parameter_init_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_session_parameter_init_list + + return p +} + +func (s *Session_parameter_init_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Session_parameter_init_listContext) AllSession_parameter_init() []ISession_parameter_initContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISession_parameter_initContext); ok { + len++ + } + } + + tst := make([]ISession_parameter_initContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISession_parameter_initContext); ok { + tst[i] = t.(ISession_parameter_initContext) + i++ + } + } + + return tst +} + +func (s *Session_parameter_init_listContext) Session_parameter_init(i int) ISession_parameter_initContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_parameter_initContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISession_parameter_initContext) +} + +func (s *Session_parameter_init_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Session_parameter_init_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Session_parameter_init_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Session_parameter_init_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Session_parameter_init_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSession_parameter_init_list(s) + } +} + +func (s *Session_parameter_init_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSession_parameter_init_list(s) + } +} + +func (s *Session_parameter_init_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSession_parameter_init_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Session_parameter_init_list() (localctx ISession_parameter_init_listContext) { + localctx = NewSession_parameter_init_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, SnowflakeParserRULE_session_parameter_init_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8935) + p.Session_parameter_init() + } + p.SetState(8940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(8936) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8937) + p.Session_parameter_init() + } + + p.SetState(8942) + 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 +} + +// ISession_parameter_initContext is an interface to support dynamic dispatch. +type ISession_parameter_initContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Session_parameter() ISession_parameterContext + EQ() antlr.TerminalNode + True_false() ITrue_falseContext + + // IsSession_parameter_initContext differentiates from other interfaces. + IsSession_parameter_initContext() +} + +type Session_parameter_initContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySession_parameter_initContext() *Session_parameter_initContext { + var p = new(Session_parameter_initContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_parameter_init + return p +} + +func InitEmptySession_parameter_initContext(p *Session_parameter_initContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_session_parameter_init +} + +func (*Session_parameter_initContext) IsSession_parameter_initContext() {} + +func NewSession_parameter_initContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Session_parameter_initContext { + var p = new(Session_parameter_initContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_session_parameter_init + + return p +} + +func (s *Session_parameter_initContext) GetParser() antlr.Parser { return s.parser } + +func (s *Session_parameter_initContext) Session_parameter() ISession_parameterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_parameterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISession_parameterContext) +} + +func (s *Session_parameter_initContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Session_parameter_initContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Session_parameter_initContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Session_parameter_initContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Session_parameter_initContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSession_parameter_init(s) + } +} + +func (s *Session_parameter_initContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSession_parameter_init(s) + } +} + +func (s *Session_parameter_initContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSession_parameter_init(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Session_parameter_init() (localctx ISession_parameter_initContext) { + localctx = NewSession_parameter_initContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, SnowflakeParserRULE_session_parameter_init) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8943) + p.Session_parameter() + } + { + p.SetState(8944) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8945) + p.True_false() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_taskContext is an interface to support dynamic dispatch. +type ICreate_taskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TASK() antlr.TerminalNode + Object_name() IObject_nameContext + AS() antlr.TerminalNode + Sql() ISqlContext + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + SCHEDULE() antlr.TerminalNode + AllEQ() []antlr.TerminalNode + EQ(i int) antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + ALLOW_OVERLAPPING_EXECUTION() antlr.TerminalNode + True_false() ITrue_falseContext + Session_parameter_init_list() ISession_parameter_init_listContext + USER_TASK_TIMEOUT_MS() antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + SUSPEND_TASK_AFTER_NUM_FAILURES() antlr.TerminalNode + ERROR_INTEGRATION() antlr.TerminalNode + Id_() IId_Context + Copy_grants() ICopy_grantsContext + Comment_clause() IComment_clauseContext + AFTER() antlr.TerminalNode + WHEN() antlr.TerminalNode + Search_condition() ISearch_conditionContext + WAREHOUSE() antlr.TerminalNode + USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_taskContext differentiates from other interfaces. + IsCreate_taskContext() +} + +type Create_taskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_taskContext() *Create_taskContext { + var p = new(Create_taskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_task + return p +} + +func InitEmptyCreate_taskContext(p *Create_taskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_task +} + +func (*Create_taskContext) IsCreate_taskContext() {} + +func NewCreate_taskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_taskContext { + var p = new(Create_taskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_task + + return p +} + +func (s *Create_taskContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_taskContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_taskContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Create_taskContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_taskContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_taskContext) Sql() ISqlContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlContext) +} + +func (s *Create_taskContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_taskContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_taskContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEDULE, 0) +} + +func (s *Create_taskContext) AllEQ() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserEQ) +} + +func (s *Create_taskContext) EQ(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, i) +} + +func (s *Create_taskContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Create_taskContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Create_taskContext) ALLOW_OVERLAPPING_EXECUTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_OVERLAPPING_EXECUTION, 0) +} + +func (s *Create_taskContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Create_taskContext) Session_parameter_init_list() ISession_parameter_init_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_parameter_init_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISession_parameter_init_listContext) +} + +func (s *Create_taskContext) USER_TASK_TIMEOUT_MS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_TASK_TIMEOUT_MS, 0) +} + +func (s *Create_taskContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Create_taskContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Create_taskContext) SUSPEND_TASK_AFTER_NUM_FAILURES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, 0) +} + +func (s *Create_taskContext) ERROR_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_INTEGRATION, 0) +} + +func (s *Create_taskContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_taskContext) Copy_grants() ICopy_grantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_grantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_grantsContext) +} + +func (s *Create_taskContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_taskContext) AFTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAFTER, 0) +} + +func (s *Create_taskContext) WHEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHEN, 0) +} + +func (s *Create_taskContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Create_taskContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Create_taskContext) USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, 0) +} + +func (s *Create_taskContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Create_taskContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Create_taskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_taskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_taskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_task(s) + } +} + +func (s *Create_taskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_task(s) + } +} + +func (s *Create_taskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_task(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_task() (localctx ICreate_taskContext) { + localctx = NewCreate_taskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, SnowflakeParserRULE_create_task) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8947) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(8948) + p.Or_replace() + } + + } + { + p.SetState(8951) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8953) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1128, p.GetParserRuleContext()) == 1 { + { + p.SetState(8952) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8955) + p.Object_name() + } + p.SetState(8962) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1129, p.GetParserRuleContext()) == 1 { + { + p.SetState(8956) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8957) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8958) + p.String_() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1129, p.GetParserRuleContext()) == 2 { + { + p.SetState(8959) + p.Match(SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8960) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8961) + p.String_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSCHEDULE { + { + p.SetState(8964) + p.Match(SnowflakeParserSCHEDULE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8965) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8966) + p.String_() + } + + } + p.SetState(8972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALLOW_OVERLAPPING_EXECUTION { + { + p.SetState(8969) + p.Match(SnowflakeParserALLOW_OVERLAPPING_EXECUTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8970) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8971) + p.True_false() + } + + } + p.SetState(8975) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1132, p.GetParserRuleContext()) == 1 { + { + p.SetState(8974) + p.Session_parameter_init_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserUSER_TASK_TIMEOUT_MS { + { + p.SetState(8977) + p.Match(SnowflakeParserUSER_TASK_TIMEOUT_MS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8978) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8979) + p.Num() + } + + } + p.SetState(8985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES { + { + p.SetState(8982) + p.Match(SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8983) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8984) + p.Num() + } + + } + p.SetState(8990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserERROR_INTEGRATION { + { + p.SetState(8987) + p.Match(SnowflakeParserERROR_INTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8988) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8989) + p.Id_() + } + + } + p.SetState(8993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(8992) + p.Copy_grants() + } + + } + p.SetState(8996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(8995) + p.Comment_clause() + } + + } + p.SetState(9007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAFTER { + { + p.SetState(8998) + p.Match(SnowflakeParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8999) + p.String_() + } + p.SetState(9004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(9000) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9001) + p.String_() + } + + p.SetState(9006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(9011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWHEN { + { + p.SetState(9009) + p.Match(SnowflakeParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9010) + p.search_condition(0) + } + + } + { + p.SetState(9013) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9014) + p.Sql() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISqlContext is an interface to support dynamic dispatch. +type ISqlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sql_command() ISql_commandContext + Call() ICallContext + DBL_DOLLAR() antlr.TerminalNode + + // IsSqlContext differentiates from other interfaces. + IsSqlContext() +} + +type SqlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySqlContext() *SqlContext { + var p = new(SqlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sql + return p +} + +func InitEmptySqlContext(p *SqlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sql +} + +func (*SqlContext) IsSqlContext() {} + +func NewSqlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SqlContext { + var p = new(SqlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_sql + + return p +} + +func (s *SqlContext) GetParser() antlr.Parser { return s.parser } + +func (s *SqlContext) Sql_command() ISql_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_commandContext) +} + +func (s *SqlContext) Call() ICallContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICallContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICallContext) +} + +func (s *SqlContext) DBL_DOLLAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDBL_DOLLAR, 0) +} + +func (s *SqlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SqlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SqlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSql(s) + } +} + +func (s *SqlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSql(s) + } +} + +func (s *SqlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSql(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Sql() (localctx ISqlContext) { + localctx = NewSqlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, SnowflakeParserRULE_sql) + p.SetState(9019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1141, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9016) + p.Sql_command() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9017) + p.Call() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9018) + p.Match(SnowflakeParserDBL_DOLLAR) + 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 +} + +// ICallContext is an interface to support dynamic dispatch. +type ICallContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CALL() antlr.TerminalNode + Object_name() IObject_nameContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Expr_list() IExpr_listContext + + // IsCallContext differentiates from other interfaces. + IsCallContext() +} + +type CallContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCallContext() *CallContext { + var p = new(CallContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_call + return p +} + +func InitEmptyCallContext(p *CallContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_call +} + +func (*CallContext) IsCallContext() {} + +func NewCallContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CallContext { + var p = new(CallContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_call + + return p +} + +func (s *CallContext) GetParser() antlr.Parser { return s.parser } + +func (s *CallContext) CALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCALL, 0) +} + +func (s *CallContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *CallContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *CallContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *CallContext) 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 *CallContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *CallContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *CallContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCall(s) + } +} + +func (s *CallContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCall(s) + } +} + +func (s *CallContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCall(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Call() (localctx ICallContext) { + localctx = NewCallContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 532, SnowflakeParserRULE_call) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9021) + p.Match(SnowflakeParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9022) + p.Object_name() + } + { + p.SetState(9023) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-211110795935745) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184908959745) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3463268149149828613) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-1099515850833) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-35184372088833) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173377025) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950977) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-36283900493953) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-216181718867017753) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&2165536527268970481) != 0) || ((int64((_la-1099)) & ^0x3f) == 0 && ((int64(1)<<(_la-1099))&787113) != 0) { + { + p.SetState(9024) + p.Expr_list() + } + + } + { + p.SetState(9027) + p.Match(SnowflakeParserRR_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 +} + +// ICreate_userContext is an interface to support dynamic dispatch. +type ICreate_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + USER() antlr.TerminalNode + Id_() IId_Context + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + Object_properties() IObject_propertiesContext + Object_params() IObject_paramsContext + Session_params() ISession_paramsContext + + // IsCreate_userContext differentiates from other interfaces. + IsCreate_userContext() +} + +type Create_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_userContext() *Create_userContext { + var p = new(Create_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_user + return p +} + +func InitEmptyCreate_userContext(p *Create_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_user +} + +func (*Create_userContext) IsCreate_userContext() {} + +func NewCreate_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_userContext { + var p = new(Create_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_user + + return p +} + +func (s *Create_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_userContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_userContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Create_userContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_userContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_userContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_userContext) Object_properties() IObject_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_propertiesContext) +} + +func (s *Create_userContext) Object_params() IObject_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_paramsContext) +} + +func (s *Create_userContext) Session_params() ISession_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISession_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISession_paramsContext) +} + +func (s *Create_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_user(s) + } +} + +func (s *Create_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_user(s) + } +} + +func (s *Create_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_user() (localctx ICreate_userContext) { + localctx = NewCreate_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 534, SnowflakeParserRULE_create_user) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9029) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(9030) + p.Or_replace() + } + + } + { + p.SetState(9033) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9035) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1144, p.GetParserRuleContext()) == 1 { + { + p.SetState(9034) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9037) + p.Id_() + } + p.SetState(9039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-161)) & ^0x3f) == 0 && ((int64(1)<<(_la-161))&-4323455642275676159) != 0) || ((int64((_la-225)) & ^0x3f) == 0 && ((int64(1)<<(_la-225))&537427969) != 0) || _la == SnowflakeParserFIRST_NAME || ((int64((_la-421)) & ^0x3f) == 0 && ((int64(1)<<(_la-421))&58546795172593665) != 0) || _la == SnowflakeParserMUST_CHANGE_PASSWORD || _la == SnowflakeParserPASSWORD || _la == SnowflakeParserRSA_PUBLIC_KEY || _la == SnowflakeParserRSA_PUBLIC_KEY_2 { + { + p.SetState(9038) + p.Object_properties() + } + + } + p.SetState(9042) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1146, p.GetParserRuleContext()) == 1 { + { + p.SetState(9041) + p.Object_params() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserABORT_DETACHED_QUERY || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&206158430209) != 0) || ((int64((_la-215)) & ^0x3f) == 0 && ((int64(1)<<(_la-215))&6917529027641081859) != 0) || _la == SnowflakeParserJSON_INDENT || _la == SnowflakeParserLOCK_TIMEOUT || _la == SnowflakeParserQUERY_TAG || _la == SnowflakeParserROWS_PER_RESULTSET || ((int64((_la-798)) & ^0x3f) == 0 && ((int64(1)<<(_la-798))&4611686293305294849) != 0) || ((int64((_la-905)) & ^0x3f) == 0 && ((int64(1)<<(_la-905))&140737756898773) != 0) || ((int64((_la-975)) & ^0x3f) == 0 && ((int64(1)<<(_la-975))&3298534948865) != 0) { + { + p.SetState(9044) + p.Session_params() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IView_colContext is an interface to support dynamic dispatch. +type IView_colContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + With_masking_policy() IWith_masking_policyContext + With_tags() IWith_tagsContext + + // IsView_colContext differentiates from other interfaces. + IsView_colContext() +} + +type View_colContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyView_colContext() *View_colContext { + var p = new(View_colContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_view_col + return p +} + +func InitEmptyView_colContext(p *View_colContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_view_col +} + +func (*View_colContext) IsView_colContext() {} + +func NewView_colContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_colContext { + var p = new(View_colContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_view_col + + return p +} + +func (s *View_colContext) GetParser() antlr.Parser { return s.parser } + +func (s *View_colContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *View_colContext) With_masking_policy() IWith_masking_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_masking_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_masking_policyContext) +} + +func (s *View_colContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *View_colContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *View_colContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *View_colContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterView_col(s) + } +} + +func (s *View_colContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitView_col(s) + } +} + +func (s *View_colContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitView_col(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) View_col() (localctx IView_colContext) { + localctx = NewView_colContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 536, SnowflakeParserRULE_view_col) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9047) + p.Column_name() + } + { + p.SetState(9048) + p.With_masking_policy() + } + { + p.SetState(9049) + p.With_tags() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_viewContext is an interface to support dynamic dispatch. +type ICreate_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + VIEW() antlr.TerminalNode + Object_name() IObject_nameContext + AS() antlr.TerminalNode + Query_statement() IQuery_statementContext + Or_replace() IOr_replaceContext + SECURE() antlr.TerminalNode + RECURSIVE() antlr.TerminalNode + If_not_exists() IIf_not_existsContext + LR_BRACKET() antlr.TerminalNode + Column_list() IColumn_listContext + RR_BRACKET() antlr.TerminalNode + AllView_col() []IView_colContext + View_col(i int) IView_colContext + With_row_access_policy() IWith_row_access_policyContext + With_tags() IWith_tagsContext + Copy_grants() ICopy_grantsContext + Comment_clause() IComment_clauseContext + + // IsCreate_viewContext differentiates from other interfaces. + IsCreate_viewContext() +} + +type Create_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_viewContext() *Create_viewContext { + var p = new(Create_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_view + return p +} + +func InitEmptyCreate_viewContext(p *Create_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_view +} + +func (*Create_viewContext) IsCreate_viewContext() {} + +func NewCreate_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_viewContext { + var p = new(Create_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_view + + return p +} + +func (s *Create_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Create_viewContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Create_viewContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Create_viewContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *Create_viewContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_viewContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Create_viewContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECURSIVE, 0) +} + +func (s *Create_viewContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_viewContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Create_viewContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Create_viewContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Create_viewContext) AllView_col() []IView_colContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IView_colContext); ok { + len++ + } + } + + tst := make([]IView_colContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IView_colContext); ok { + tst[i] = t.(IView_colContext) + i++ + } + } + + return tst +} + +func (s *Create_viewContext) View_col(i int) IView_colContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IView_colContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IView_colContext) +} + +func (s *Create_viewContext) With_row_access_policy() IWith_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_row_access_policyContext) +} + +func (s *Create_viewContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Create_viewContext) Copy_grants() ICopy_grantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICopy_grantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICopy_grantsContext) +} + +func (s *Create_viewContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Create_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_view(s) + } +} + +func (s *Create_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_view(s) + } +} + +func (s *Create_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_view() (localctx ICreate_viewContext) { + localctx = NewCreate_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 538, SnowflakeParserRULE_create_view) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9051) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(9052) + p.Or_replace() + } + + } + p.SetState(9056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSECURE { + { + p.SetState(9055) + p.Match(SnowflakeParserSECURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserRECURSIVE { + { + p.SetState(9058) + p.Match(SnowflakeParserRECURSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9061) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9063) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1151, p.GetParserRuleContext()) == 1 { + { + p.SetState(9062) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9065) + p.Object_name() + } + p.SetState(9070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(9066) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9067) + p.Column_list() + } + { + p.SetState(9068) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1153, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9072) + p.View_col() + } + + } + p.SetState(9077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1153, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(9079) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1154, p.GetParserRuleContext()) == 1 { + { + p.SetState(9078) + p.With_row_access_policy() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(9081) + p.With_tags() + } + + } + p.SetState(9085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOPY { + { + p.SetState(9084) + p.Copy_grants() + } + + } + p.SetState(9088) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMENT { + { + p.SetState(9087) + p.Comment_clause() + } + + } + { + p.SetState(9090) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9091) + p.Query_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_warehouseContext is an interface to support dynamic dispatch. +type ICreate_warehouseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + Id_() IId_Context + Or_replace() IOr_replaceContext + If_not_exists() IIf_not_existsContext + AllWh_params() []IWh_paramsContext + Wh_params(i int) IWh_paramsContext + WITH() antlr.TerminalNode + AllWh_properties() []IWh_propertiesContext + Wh_properties(i int) IWh_propertiesContext + + // IsCreate_warehouseContext differentiates from other interfaces. + IsCreate_warehouseContext() +} + +type Create_warehouseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_warehouseContext() *Create_warehouseContext { + var p = new(Create_warehouseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_warehouse + return p +} + +func InitEmptyCreate_warehouseContext(p *Create_warehouseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_create_warehouse +} + +func (*Create_warehouseContext) IsCreate_warehouseContext() {} + +func NewCreate_warehouseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_warehouseContext { + var p = new(Create_warehouseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_create_warehouse + + return p +} + +func (s *Create_warehouseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_warehouseContext) CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREATE, 0) +} + +func (s *Create_warehouseContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Create_warehouseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Create_warehouseContext) Or_replace() IOr_replaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOr_replaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOr_replaceContext) +} + +func (s *Create_warehouseContext) If_not_exists() IIf_not_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_not_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_not_existsContext) +} + +func (s *Create_warehouseContext) AllWh_params() []IWh_paramsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWh_paramsContext); ok { + len++ + } + } + + tst := make([]IWh_paramsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWh_paramsContext); ok { + tst[i] = t.(IWh_paramsContext) + i++ + } + } + + return tst +} + +func (s *Create_warehouseContext) Wh_params(i int) IWh_paramsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWh_paramsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWh_paramsContext) +} + +func (s *Create_warehouseContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Create_warehouseContext) AllWh_properties() []IWh_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWh_propertiesContext); ok { + len++ + } + } + + tst := make([]IWh_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWh_propertiesContext); ok { + tst[i] = t.(IWh_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Create_warehouseContext) Wh_properties(i int) IWh_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWh_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWh_propertiesContext) +} + +func (s *Create_warehouseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_warehouseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_warehouseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCreate_warehouse(s) + } +} + +func (s *Create_warehouseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCreate_warehouse(s) + } +} + +func (s *Create_warehouseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCreate_warehouse(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Create_warehouse() (localctx ICreate_warehouseContext) { + localctx = NewCreate_warehouseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 540, SnowflakeParserRULE_create_warehouse) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9093) + p.Match(SnowflakeParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOR { + { + p.SetState(9094) + p.Or_replace() + } + + } + { + p.SetState(9097) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9099) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1159, p.GetParserRuleContext()) == 1 { + { + p.SetState(9098) + p.If_not_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9101) + p.Id_() + } + p.SetState(9110) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAUTO_RESUME || _la == SnowflakeParserAUTO_SUSPEND || _la == SnowflakeParserCOMMENT || _la == SnowflakeParserECONOMY || _la == SnowflakeParserENABLE_QUERY_ACCELERATION || _la == SnowflakeParserINITIALLY_SUSPENDED || _la == SnowflakeParserMAX_CLUSTER_COUNT || _la == SnowflakeParserMIN_CLUSTER_COUNT || _la == SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR || _la == SnowflakeParserRESOURCE_MONITOR || _la == SnowflakeParserSCALING_POLICY || _la == SnowflakeParserWAREHOUSE_SIZE || _la == SnowflakeParserWITH { + p.SetState(9103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(9102) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserAUTO_RESUME || _la == SnowflakeParserAUTO_SUSPEND || _la == SnowflakeParserCOMMENT || _la == SnowflakeParserECONOMY || _la == SnowflakeParserENABLE_QUERY_ACCELERATION || _la == SnowflakeParserINITIALLY_SUSPENDED || _la == SnowflakeParserMAX_CLUSTER_COUNT || _la == SnowflakeParserMIN_CLUSTER_COUNT || _la == SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR || _la == SnowflakeParserRESOURCE_MONITOR || _la == SnowflakeParserSCALING_POLICY || _la == SnowflakeParserWAREHOUSE_SIZE { + { + p.SetState(9105) + p.Wh_properties() + } + + p.SetState(9108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(9115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserMAX_CONCURRENCY_LEVEL || _la == SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS || _la == SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS { + { + p.SetState(9112) + p.Wh_params() + } + + p.SetState(9117) + 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 +} + +// IWh_propertiesContext is an interface to support dynamic dispatch. +type IWh_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAREHOUSE_SIZE() antlr.TerminalNode + EQ() antlr.TerminalNode + XSMALL() antlr.TerminalNode + SMALL() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + LARGE() antlr.TerminalNode + XLARGE() antlr.TerminalNode + XXLARGE() antlr.TerminalNode + XXXLARGE() antlr.TerminalNode + X4LARGE() antlr.TerminalNode + X5LARGE() antlr.TerminalNode + X6LARGE() antlr.TerminalNode + MAX_CLUSTER_COUNT() antlr.TerminalNode + Num() INumContext + MIN_CLUSTER_COUNT() antlr.TerminalNode + SCALING_POLICY() antlr.TerminalNode + STANDARD() antlr.TerminalNode + ECONOMY() antlr.TerminalNode + AUTO_SUSPEND() antlr.TerminalNode + NULL_() antlr.TerminalNode + AUTO_RESUME() antlr.TerminalNode + True_false() ITrue_falseContext + INITIALLY_SUSPENDED() antlr.TerminalNode + RESOURCE_MONITOR() antlr.TerminalNode + Id_() IId_Context + Comment_clause() IComment_clauseContext + ENABLE_QUERY_ACCELERATION() antlr.TerminalNode + QUERY_ACCELERATION_MAX_SCALE_FACTOR() antlr.TerminalNode + + // IsWh_propertiesContext differentiates from other interfaces. + IsWh_propertiesContext() +} + +type Wh_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWh_propertiesContext() *Wh_propertiesContext { + var p = new(Wh_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_wh_properties + return p +} + +func InitEmptyWh_propertiesContext(p *Wh_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_wh_properties +} + +func (*Wh_propertiesContext) IsWh_propertiesContext() {} + +func NewWh_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Wh_propertiesContext { + var p = new(Wh_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_wh_properties + + return p +} + +func (s *Wh_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Wh_propertiesContext) WAREHOUSE_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE_SIZE, 0) +} + +func (s *Wh_propertiesContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Wh_propertiesContext) XSMALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXSMALL, 0) +} + +func (s *Wh_propertiesContext) SMALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSMALL, 0) +} + +func (s *Wh_propertiesContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMEDIUM, 0) +} + +func (s *Wh_propertiesContext) LARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLARGE, 0) +} + +func (s *Wh_propertiesContext) XLARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXLARGE, 0) +} + +func (s *Wh_propertiesContext) XXLARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXXLARGE, 0) +} + +func (s *Wh_propertiesContext) XXXLARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXXXLARGE, 0) +} + +func (s *Wh_propertiesContext) X4LARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserX4LARGE, 0) +} + +func (s *Wh_propertiesContext) X5LARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserX5LARGE, 0) +} + +func (s *Wh_propertiesContext) X6LARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserX6LARGE, 0) +} + +func (s *Wh_propertiesContext) MAX_CLUSTER_COUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_CLUSTER_COUNT, 0) +} + +func (s *Wh_propertiesContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Wh_propertiesContext) MIN_CLUSTER_COUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMIN_CLUSTER_COUNT, 0) +} + +func (s *Wh_propertiesContext) SCALING_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCALING_POLICY, 0) +} + +func (s *Wh_propertiesContext) STANDARD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTANDARD, 0) +} + +func (s *Wh_propertiesContext) ECONOMY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserECONOMY, 0) +} + +func (s *Wh_propertiesContext) AUTO_SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_SUSPEND, 0) +} + +func (s *Wh_propertiesContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Wh_propertiesContext) AUTO_RESUME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_RESUME, 0) +} + +func (s *Wh_propertiesContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Wh_propertiesContext) INITIALLY_SUSPENDED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINITIALLY_SUSPENDED, 0) +} + +func (s *Wh_propertiesContext) RESOURCE_MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE_MONITOR, 0) +} + +func (s *Wh_propertiesContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Wh_propertiesContext) Comment_clause() IComment_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_clauseContext) +} + +func (s *Wh_propertiesContext) ENABLE_QUERY_ACCELERATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_QUERY_ACCELERATION, 0) +} + +func (s *Wh_propertiesContext) QUERY_ACCELERATION_MAX_SCALE_FACTOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, 0) +} + +func (s *Wh_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Wh_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Wh_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterWh_properties(s) + } +} + +func (s *Wh_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitWh_properties(s) + } +} + +func (s *Wh_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitWh_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Wh_properties() (localctx IWh_propertiesContext) { + localctx = NewWh_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 542, SnowflakeParserRULE_wh_properties) + var _la int + + p.SetState(9153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserWAREHOUSE_SIZE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9118) + p.Match(SnowflakeParserWAREHOUSE_SIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9119) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9120) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserLARGE || _la == SnowflakeParserMEDIUM || _la == SnowflakeParserSMALL || ((int64((_la-1027)) & ^0x3f) == 0 && ((int64(1)<<(_la-1027))&911) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserMAX_CLUSTER_COUNT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9121) + p.Match(SnowflakeParserMAX_CLUSTER_COUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9122) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9123) + p.Num() + } + + case SnowflakeParserMIN_CLUSTER_COUNT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9124) + p.Match(SnowflakeParserMIN_CLUSTER_COUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9125) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9126) + p.Num() + } + + case SnowflakeParserSCALING_POLICY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9127) + p.Match(SnowflakeParserSCALING_POLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9128) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9129) + p.Match(SnowflakeParserSTANDARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserECONOMY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9130) + p.Match(SnowflakeParserECONOMY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAUTO_SUSPEND: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9131) + p.Match(SnowflakeParserAUTO_SUSPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserEQ: + { + p.SetState(9132) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9133) + p.Num() + } + + case SnowflakeParserNULL_: + { + p.SetState(9134) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case SnowflakeParserAUTO_RESUME: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9137) + p.Match(SnowflakeParserAUTO_RESUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9138) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9139) + p.True_false() + } + + case SnowflakeParserINITIALLY_SUSPENDED: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9140) + p.Match(SnowflakeParserINITIALLY_SUSPENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9141) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9142) + p.True_false() + } + + case SnowflakeParserRESOURCE_MONITOR: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9143) + p.Match(SnowflakeParserRESOURCE_MONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9144) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9145) + p.Id_() + } + + case SnowflakeParserCOMMENT: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9146) + p.Comment_clause() + } + + case SnowflakeParserENABLE_QUERY_ACCELERATION: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9147) + p.Match(SnowflakeParserENABLE_QUERY_ACCELERATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9148) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9149) + p.True_false() + } + + case SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9150) + p.Match(SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9151) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9152) + p.Num() + } + + 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 +} + +// IWh_paramsContext is an interface to support dynamic dispatch. +type IWh_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAX_CONCURRENCY_LEVEL() antlr.TerminalNode + EQ() antlr.TerminalNode + Num() INumContext + STATEMENT_QUEUED_TIMEOUT_IN_SECONDS() antlr.TerminalNode + STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode + With_tags() IWith_tagsContext + + // IsWh_paramsContext differentiates from other interfaces. + IsWh_paramsContext() +} + +type Wh_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWh_paramsContext() *Wh_paramsContext { + var p = new(Wh_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_wh_params + return p +} + +func InitEmptyWh_paramsContext(p *Wh_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_wh_params +} + +func (*Wh_paramsContext) IsWh_paramsContext() {} + +func NewWh_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Wh_paramsContext { + var p = new(Wh_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_wh_params + + return p +} + +func (s *Wh_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Wh_paramsContext) MAX_CONCURRENCY_LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_CONCURRENCY_LEVEL, 0) +} + +func (s *Wh_paramsContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Wh_paramsContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Wh_paramsContext) STATEMENT_QUEUED_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Wh_paramsContext) STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Wh_paramsContext) With_tags() IWith_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_tagsContext) +} + +func (s *Wh_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Wh_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Wh_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterWh_params(s) + } +} + +func (s *Wh_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitWh_params(s) + } +} + +func (s *Wh_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitWh_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Wh_params() (localctx IWh_paramsContext) { + localctx = NewWh_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 544, SnowflakeParserRULE_wh_params) + var _la int + + p.SetState(9167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserMAX_CONCURRENCY_LEVEL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9155) + p.Match(SnowflakeParserMAX_CONCURRENCY_LEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9156) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9157) + p.Num() + } + + case SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9158) + p.Match(SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9159) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9160) + p.Num() + } + + case SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9161) + p.Match(SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9162) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9163) + p.Num() + } + p.SetState(9165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTAG || _la == SnowflakeParserWITH { + { + p.SetState(9164) + p.With_tags() + } + + } + + 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 +} + +// ITrigger_definitionContext is an interface to support dynamic dispatch. +type ITrigger_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Num() INumContext + PERCENT() antlr.TerminalNode + DO() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + SUSPEND_IMMEDIATE() antlr.TerminalNode + NOTIFY() antlr.TerminalNode + + // IsTrigger_definitionContext differentiates from other interfaces. + IsTrigger_definitionContext() +} + +type Trigger_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_definitionContext() *Trigger_definitionContext { + var p = new(Trigger_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_trigger_definition + return p +} + +func InitEmptyTrigger_definitionContext(p *Trigger_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_trigger_definition +} + +func (*Trigger_definitionContext) IsTrigger_definitionContext() {} + +func NewTrigger_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_definitionContext { + var p = new(Trigger_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_trigger_definition + + return p +} + +func (s *Trigger_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_definitionContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Trigger_definitionContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Trigger_definitionContext) PERCENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERCENT, 0) +} + +func (s *Trigger_definitionContext) DO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDO, 0) +} + +func (s *Trigger_definitionContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND, 0) +} + +func (s *Trigger_definitionContext) SUSPEND_IMMEDIATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND_IMMEDIATE, 0) +} + +func (s *Trigger_definitionContext) NOTIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFY, 0) +} + +func (s *Trigger_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTrigger_definition(s) + } +} + +func (s *Trigger_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTrigger_definition(s) + } +} + +func (s *Trigger_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTrigger_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Trigger_definition() (localctx ITrigger_definitionContext) { + localctx = NewTrigger_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 546, SnowflakeParserRULE_trigger_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9169) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9170) + p.Num() + } + { + p.SetState(9171) + p.Match(SnowflakeParserPERCENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9172) + p.Match(SnowflakeParserDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9173) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserNOTIFY || _la == SnowflakeParserSUSPEND || _la == SnowflakeParserSUSPEND_IMMEDIATE) { + 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 +} + +// 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 + ROLE() antlr.TerminalNode + USER() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + NETWORK() antlr.TerminalNode + POLICY() antlr.TerminalNode + SESSION() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + TABLE() antlr.TerminalNode + VIEW() antlr.TerminalNode + STAGE() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + STREAM() antlr.TerminalNode + TASK() antlr.TerminalNode + MASKING() antlr.TerminalNode + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + TAG() antlr.TerminalNode + PIPE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + SEQUENCE() 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 = SnowflakeParserRULE_object_type_name + return p +} + +func InitEmptyObject_type_nameContext(p *Object_type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_object_type_name + + return p +} + +func (s *Object_type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_nameContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Object_type_nameContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Object_type_nameContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Object_type_nameContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Object_type_nameContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Object_type_nameContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Object_type_nameContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Object_type_nameContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Object_type_nameContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Object_type_nameContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Object_type_nameContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Object_type_nameContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Object_type_nameContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Object_type_nameContext) FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT, 0) +} + +func (s *Object_type_nameContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Object_type_nameContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Object_type_nameContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Object_type_nameContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Object_type_nameContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Object_type_nameContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Object_type_nameContext) PIPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE, 0) +} + +func (s *Object_type_nameContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Object_type_nameContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE, 0) +} + +func (s *Object_type_nameContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 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.(SnowflakeParserListener); ok { + listenerT.EnterObject_type_name(s) + } +} + +func (s *Object_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_type_name(s) + } +} + +func (s *Object_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_type_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_type_name() (localctx IObject_type_nameContext) { + localctx = NewObject_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 548, SnowflakeParserRULE_object_type_name) + p.SetState(9202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserROLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9175) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUSER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9176) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserWAREHOUSE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9177) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserINTEGRATION: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9178) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNETWORK: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9179) + p.Match(SnowflakeParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9180) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSESSION: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9181) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9182) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9183) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSCHEMA: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9184) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTABLE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9185) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserVIEW: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9186) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTAGE: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9187) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFILE: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9188) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9189) + p.Match(SnowflakeParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSTREAM: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(9190) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTASK: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(9191) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserMASKING: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(9192) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9193) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserROW: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(9194) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9195) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9196) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTAG: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(9197) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserPIPE: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(9198) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFUNCTION: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(9199) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserPROCEDURE: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(9200) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSEQUENCE: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(9201) + p.Match(SnowflakeParserSEQUENCE) + 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_pluralContext is an interface to support dynamic dispatch. +type IObject_type_pluralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLES() antlr.TerminalNode + USERS() antlr.TerminalNode + WAREHOUSES() antlr.TerminalNode + INTEGRATIONS() antlr.TerminalNode + DATABASES() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + TABLES() antlr.TerminalNode + VIEWS() antlr.TerminalNode + STAGES() antlr.TerminalNode + STREAMS() antlr.TerminalNode + TASKS() antlr.TerminalNode + + // IsObject_type_pluralContext differentiates from other interfaces. + IsObject_type_pluralContext() +} + +type Object_type_pluralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_type_pluralContext() *Object_type_pluralContext { + var p = new(Object_type_pluralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_type_plural + return p +} + +func InitEmptyObject_type_pluralContext(p *Object_type_pluralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_type_plural +} + +func (*Object_type_pluralContext) IsObject_type_pluralContext() {} + +func NewObject_type_pluralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_pluralContext { + var p = new(Object_type_pluralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_object_type_plural + + return p +} + +func (s *Object_type_pluralContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_pluralContext) ROLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLES, 0) +} + +func (s *Object_type_pluralContext) USERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSERS, 0) +} + +func (s *Object_type_pluralContext) WAREHOUSES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSES, 0) +} + +func (s *Object_type_pluralContext) INTEGRATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATIONS, 0) +} + +func (s *Object_type_pluralContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Object_type_pluralContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMAS, 0) +} + +func (s *Object_type_pluralContext) TABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLES, 0) +} + +func (s *Object_type_pluralContext) VIEWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEWS, 0) +} + +func (s *Object_type_pluralContext) STAGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGES, 0) +} + +func (s *Object_type_pluralContext) STREAMS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAMS, 0) +} + +func (s *Object_type_pluralContext) TASKS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASKS, 0) +} + +func (s *Object_type_pluralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_pluralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_pluralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterObject_type_plural(s) + } +} + +func (s *Object_type_pluralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_type_plural(s) + } +} + +func (s *Object_type_pluralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_type_plural(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_type_plural() (localctx IObject_type_pluralContext) { + localctx = NewObject_type_pluralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 550, SnowflakeParserRULE_object_type_plural) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9204) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDATABASES || _la == SnowflakeParserINTEGRATIONS || _la == SnowflakeParserROLES || _la == SnowflakeParserSCHEMAS || ((int64((_la-823)) & ^0x3f) == 0 && ((int64(1)<<(_la-823))&1152921538966585345) != 0) || _la == SnowflakeParserTASKS || ((int64((_la-986)) & ^0x3f) == 0 && ((int64(1)<<(_la-986))&68157441) != 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 +} + +// IDrop_commandContext is an interface to support dynamic dispatch. +type IDrop_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Drop_object() IDrop_objectContext + Drop_alert() IDrop_alertContext + Drop_connection() IDrop_connectionContext + Drop_database() IDrop_databaseContext + Drop_dynamic_table() IDrop_dynamic_tableContext + Drop_external_table() IDrop_external_tableContext + Drop_failover_group() IDrop_failover_groupContext + Drop_file_format() IDrop_file_formatContext + Drop_function() IDrop_functionContext + Drop_integration() IDrop_integrationContext + Drop_managed_account() IDrop_managed_accountContext + Drop_masking_policy() IDrop_masking_policyContext + Drop_materialized_view() IDrop_materialized_viewContext + Drop_network_policy() IDrop_network_policyContext + Drop_pipe() IDrop_pipeContext + Drop_procedure() IDrop_procedureContext + Drop_replication_group() IDrop_replication_groupContext + Drop_resource_monitor() IDrop_resource_monitorContext + Drop_role() IDrop_roleContext + Drop_row_access_policy() IDrop_row_access_policyContext + Drop_schema() IDrop_schemaContext + Drop_sequence() IDrop_sequenceContext + Drop_session_policy() IDrop_session_policyContext + Drop_share() IDrop_shareContext + Drop_stage() IDrop_stageContext + Drop_stream() IDrop_streamContext + Drop_table() IDrop_tableContext + Drop_tag() IDrop_tagContext + Drop_task() IDrop_taskContext + Drop_user() IDrop_userContext + Drop_view() IDrop_viewContext + Drop_warehouse() IDrop_warehouseContext + + // IsDrop_commandContext differentiates from other interfaces. + IsDrop_commandContext() +} + +type Drop_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_commandContext() *Drop_commandContext { + var p = new(Drop_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_command + return p +} + +func InitEmptyDrop_commandContext(p *Drop_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_command +} + +func (*Drop_commandContext) IsDrop_commandContext() {} + +func NewDrop_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_commandContext { + var p = new(Drop_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_command + + return p +} + +func (s *Drop_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_commandContext) Drop_object() IDrop_objectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_objectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_objectContext) +} + +func (s *Drop_commandContext) Drop_alert() IDrop_alertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_alertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_alertContext) +} + +func (s *Drop_commandContext) Drop_connection() IDrop_connectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_connectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_connectionContext) +} + +func (s *Drop_commandContext) Drop_database() IDrop_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_databaseContext) +} + +func (s *Drop_commandContext) Drop_dynamic_table() IDrop_dynamic_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_dynamic_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_dynamic_tableContext) +} + +func (s *Drop_commandContext) Drop_external_table() IDrop_external_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_external_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_external_tableContext) +} + +func (s *Drop_commandContext) Drop_failover_group() IDrop_failover_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_failover_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_failover_groupContext) +} + +func (s *Drop_commandContext) Drop_file_format() IDrop_file_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_file_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_file_formatContext) +} + +func (s *Drop_commandContext) Drop_function() IDrop_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_functionContext) +} + +func (s *Drop_commandContext) Drop_integration() IDrop_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_integrationContext) +} + +func (s *Drop_commandContext) Drop_managed_account() IDrop_managed_accountContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_managed_accountContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_managed_accountContext) +} + +func (s *Drop_commandContext) Drop_masking_policy() IDrop_masking_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_masking_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_masking_policyContext) +} + +func (s *Drop_commandContext) Drop_materialized_view() IDrop_materialized_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_materialized_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_materialized_viewContext) +} + +func (s *Drop_commandContext) Drop_network_policy() IDrop_network_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_network_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_network_policyContext) +} + +func (s *Drop_commandContext) Drop_pipe() IDrop_pipeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_pipeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_pipeContext) +} + +func (s *Drop_commandContext) Drop_procedure() IDrop_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_procedureContext) +} + +func (s *Drop_commandContext) Drop_replication_group() IDrop_replication_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_replication_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_replication_groupContext) +} + +func (s *Drop_commandContext) Drop_resource_monitor() IDrop_resource_monitorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_resource_monitorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_resource_monitorContext) +} + +func (s *Drop_commandContext) Drop_role() IDrop_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_roleContext) +} + +func (s *Drop_commandContext) Drop_row_access_policy() IDrop_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_row_access_policyContext) +} + +func (s *Drop_commandContext) Drop_schema() IDrop_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_schemaContext) +} + +func (s *Drop_commandContext) Drop_sequence() IDrop_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_sequenceContext) +} + +func (s *Drop_commandContext) Drop_session_policy() IDrop_session_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_session_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_session_policyContext) +} + +func (s *Drop_commandContext) Drop_share() IDrop_shareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_shareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_shareContext) +} + +func (s *Drop_commandContext) Drop_stage() IDrop_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_stageContext) +} + +func (s *Drop_commandContext) Drop_stream() IDrop_streamContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_streamContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_streamContext) +} + +func (s *Drop_commandContext) Drop_table() IDrop_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_tableContext) +} + +func (s *Drop_commandContext) Drop_tag() IDrop_tagContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_tagContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_tagContext) +} + +func (s *Drop_commandContext) Drop_task() IDrop_taskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_taskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_taskContext) +} + +func (s *Drop_commandContext) Drop_user() IDrop_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_userContext) +} + +func (s *Drop_commandContext) Drop_view() IDrop_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_viewContext) +} + +func (s *Drop_commandContext) Drop_warehouse() IDrop_warehouseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_warehouseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_warehouseContext) +} + +func (s *Drop_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_command(s) + } +} + +func (s *Drop_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_command(s) + } +} + +func (s *Drop_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_command() (localctx IDrop_commandContext) { + localctx = NewDrop_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 552, SnowflakeParserRULE_drop_command) + p.SetState(9238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1169, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9206) + p.Drop_object() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9207) + p.Drop_alert() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9208) + p.Drop_connection() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9209) + p.Drop_database() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9210) + p.Drop_dynamic_table() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9211) + p.Drop_external_table() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9212) + p.Drop_failover_group() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9213) + p.Drop_file_format() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9214) + p.Drop_function() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9215) + p.Drop_integration() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9216) + p.Drop_managed_account() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9217) + p.Drop_masking_policy() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(9218) + p.Drop_materialized_view() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(9219) + p.Drop_network_policy() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(9220) + p.Drop_pipe() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(9221) + p.Drop_procedure() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(9222) + p.Drop_replication_group() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(9223) + p.Drop_resource_monitor() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(9224) + p.Drop_role() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(9225) + p.Drop_row_access_policy() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(9226) + p.Drop_schema() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(9227) + p.Drop_sequence() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(9228) + p.Drop_session_policy() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(9229) + p.Drop_share() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(9230) + p.Drop_stage() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(9231) + p.Drop_stream() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(9232) + p.Drop_table() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(9233) + p.Drop_tag() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(9234) + p.Drop_task() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(9235) + p.Drop_user() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(9236) + p.Drop_view() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(9237) + p.Drop_warehouse() + } + + 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 +} + +// IDrop_objectContext is an interface to support dynamic dispatch. +type IDrop_objectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + Object_type() IObject_typeContext + If_exists() IIf_existsContext + Id_() IId_Context + Cascade_restrict() ICascade_restrictContext + + // IsDrop_objectContext differentiates from other interfaces. + IsDrop_objectContext() +} + +type Drop_objectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_objectContext() *Drop_objectContext { + var p = new(Drop_objectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_object + return p +} + +func InitEmptyDrop_objectContext(p *Drop_objectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_object +} + +func (*Drop_objectContext) IsDrop_objectContext() {} + +func NewDrop_objectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_objectContext { + var p = new(Drop_objectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_object + + return p +} + +func (s *Drop_objectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_objectContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_objectContext) Object_type() IObject_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_typeContext) +} + +func (s *Drop_objectContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_objectContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_objectContext) Cascade_restrict() ICascade_restrictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICascade_restrictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICascade_restrictContext) +} + +func (s *Drop_objectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_objectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_objectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_object(s) + } +} + +func (s *Drop_objectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_object(s) + } +} + +func (s *Drop_objectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_object(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_object() (localctx IDrop_objectContext) { + localctx = NewDrop_objectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 554, SnowflakeParserRULE_drop_object) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9240) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9241) + p.Object_type() + } + { + p.SetState(9242) + p.If_exists() + } + { + p.SetState(9243) + p.Id_() + } + p.SetState(9245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT { + { + p.SetState(9244) + p.Cascade_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 +} + +// IDrop_alertContext is an interface to support dynamic dispatch. +type IDrop_alertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + ALERT() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_alertContext differentiates from other interfaces. + IsDrop_alertContext() +} + +type Drop_alertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_alertContext() *Drop_alertContext { + var p = new(Drop_alertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_alert + return p +} + +func InitEmptyDrop_alertContext(p *Drop_alertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_alert +} + +func (*Drop_alertContext) IsDrop_alertContext() {} + +func NewDrop_alertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_alertContext { + var p = new(Drop_alertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_alert + + return p +} + +func (s *Drop_alertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_alertContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_alertContext) ALERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERT, 0) +} + +func (s *Drop_alertContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_alertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_alertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_alertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_alert(s) + } +} + +func (s *Drop_alertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_alert(s) + } +} + +func (s *Drop_alertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_alert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_alert() (localctx IDrop_alertContext) { + localctx = NewDrop_alertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 556, SnowflakeParserRULE_drop_alert) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9247) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9248) + p.Match(SnowflakeParserALERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9249) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_connectionContext is an interface to support dynamic dispatch. +type IDrop_connectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + CONNECTION() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_connectionContext differentiates from other interfaces. + IsDrop_connectionContext() +} + +type Drop_connectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_connectionContext() *Drop_connectionContext { + var p = new(Drop_connectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_connection + return p +} + +func InitEmptyDrop_connectionContext(p *Drop_connectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_connection +} + +func (*Drop_connectionContext) IsDrop_connectionContext() {} + +func NewDrop_connectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_connectionContext { + var p = new(Drop_connectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_connection + + return p +} + +func (s *Drop_connectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_connectionContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_connectionContext) CONNECTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONNECTION, 0) +} + +func (s *Drop_connectionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_connectionContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_connectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_connectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_connectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_connection(s) + } +} + +func (s *Drop_connectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_connection(s) + } +} + +func (s *Drop_connectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_connection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_connection() (localctx IDrop_connectionContext) { + localctx = NewDrop_connectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 558, SnowflakeParserRULE_drop_connection) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9251) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9252) + p.Match(SnowflakeParserCONNECTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9254) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1171, p.GetParserRuleContext()) == 1 { + { + p.SetState(9253) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9256) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_databaseContext is an interface to support dynamic dispatch. +type IDrop_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + Cascade_restrict() ICascade_restrictContext + + // IsDrop_databaseContext differentiates from other interfaces. + IsDrop_databaseContext() +} + +type Drop_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_databaseContext() *Drop_databaseContext { + var p = new(Drop_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_database + return p +} + +func InitEmptyDrop_databaseContext(p *Drop_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_database +} + +func (*Drop_databaseContext) IsDrop_databaseContext() {} + +func NewDrop_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_databaseContext { + var p = new(Drop_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_database + + return p +} + +func (s *Drop_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_databaseContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Drop_databaseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_databaseContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_databaseContext) Cascade_restrict() ICascade_restrictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICascade_restrictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICascade_restrictContext) +} + +func (s *Drop_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_database(s) + } +} + +func (s *Drop_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_database(s) + } +} + +func (s *Drop_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_database() (localctx IDrop_databaseContext) { + localctx = NewDrop_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 560, SnowflakeParserRULE_drop_database) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9258) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9259) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9261) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1172, p.GetParserRuleContext()) == 1 { + { + p.SetState(9260) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9263) + p.Id_() + } + p.SetState(9265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT { + { + p.SetState(9264) + p.Cascade_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 +} + +// IDrop_dynamic_tableContext is an interface to support dynamic dispatch. +type IDrop_dynamic_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + TABLE() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_dynamic_tableContext differentiates from other interfaces. + IsDrop_dynamic_tableContext() +} + +type Drop_dynamic_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_dynamic_tableContext() *Drop_dynamic_tableContext { + var p = new(Drop_dynamic_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_dynamic_table + return p +} + +func InitEmptyDrop_dynamic_tableContext(p *Drop_dynamic_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_dynamic_table +} + +func (*Drop_dynamic_tableContext) IsDrop_dynamic_tableContext() {} + +func NewDrop_dynamic_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_dynamic_tableContext { + var p = new(Drop_dynamic_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_dynamic_table + + return p +} + +func (s *Drop_dynamic_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_dynamic_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_dynamic_tableContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDYNAMIC, 0) +} + +func (s *Drop_dynamic_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Drop_dynamic_tableContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_dynamic_tableContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_dynamic_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_dynamic_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_dynamic_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_dynamic_table(s) + } +} + +func (s *Drop_dynamic_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_dynamic_table(s) + } +} + +func (s *Drop_dynamic_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_dynamic_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_dynamic_table() (localctx IDrop_dynamic_tableContext) { + localctx = NewDrop_dynamic_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 562, SnowflakeParserRULE_drop_dynamic_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9267) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9268) + p.Match(SnowflakeParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9269) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9271) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1174, p.GetParserRuleContext()) == 1 { + { + p.SetState(9270) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9273) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_external_tableContext is an interface to support dynamic dispatch. +type IDrop_external_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + Cascade_restrict() ICascade_restrictContext + + // IsDrop_external_tableContext differentiates from other interfaces. + IsDrop_external_tableContext() +} + +type Drop_external_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_external_tableContext() *Drop_external_tableContext { + var p = new(Drop_external_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_external_table + return p +} + +func InitEmptyDrop_external_tableContext(p *Drop_external_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_external_table +} + +func (*Drop_external_tableContext) IsDrop_external_tableContext() {} + +func NewDrop_external_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_external_tableContext { + var p = new(Drop_external_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_external_table + + return p +} + +func (s *Drop_external_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_external_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_external_tableContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Drop_external_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Drop_external_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_external_tableContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_external_tableContext) Cascade_restrict() ICascade_restrictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICascade_restrictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICascade_restrictContext) +} + +func (s *Drop_external_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_external_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_external_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_external_table(s) + } +} + +func (s *Drop_external_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_external_table(s) + } +} + +func (s *Drop_external_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_external_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_external_table() (localctx IDrop_external_tableContext) { + localctx = NewDrop_external_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 564, SnowflakeParserRULE_drop_external_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9275) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9276) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9277) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9279) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1175, p.GetParserRuleContext()) == 1 { + { + p.SetState(9278) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9281) + p.Object_name() + } + p.SetState(9283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT { + { + p.SetState(9282) + p.Cascade_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 +} + +// IDrop_failover_groupContext is an interface to support dynamic dispatch. +type IDrop_failover_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_failover_groupContext differentiates from other interfaces. + IsDrop_failover_groupContext() +} + +type Drop_failover_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_failover_groupContext() *Drop_failover_groupContext { + var p = new(Drop_failover_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_failover_group + return p +} + +func InitEmptyDrop_failover_groupContext(p *Drop_failover_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_failover_group +} + +func (*Drop_failover_groupContext) IsDrop_failover_groupContext() {} + +func NewDrop_failover_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_failover_groupContext { + var p = new(Drop_failover_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_failover_group + + return p +} + +func (s *Drop_failover_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_failover_groupContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_failover_groupContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, 0) +} + +func (s *Drop_failover_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Drop_failover_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_failover_groupContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_failover_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_failover_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_failover_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_failover_group(s) + } +} + +func (s *Drop_failover_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_failover_group(s) + } +} + +func (s *Drop_failover_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_failover_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_failover_group() (localctx IDrop_failover_groupContext) { + localctx = NewDrop_failover_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 566, SnowflakeParserRULE_drop_failover_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9285) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9286) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9287) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9289) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1177, p.GetParserRuleContext()) == 1 { + { + p.SetState(9288) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9291) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_file_formatContext is an interface to support dynamic dispatch. +type IDrop_file_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_file_formatContext differentiates from other interfaces. + IsDrop_file_formatContext() +} + +type Drop_file_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_file_formatContext() *Drop_file_formatContext { + var p = new(Drop_file_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_file_format + return p +} + +func InitEmptyDrop_file_formatContext(p *Drop_file_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_file_format +} + +func (*Drop_file_formatContext) IsDrop_file_formatContext() {} + +func NewDrop_file_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_file_formatContext { + var p = new(Drop_file_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_file_format + + return p +} + +func (s *Drop_file_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_file_formatContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_file_formatContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Drop_file_formatContext) FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT, 0) +} + +func (s *Drop_file_formatContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_file_formatContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_file_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_file_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_file_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_file_format(s) + } +} + +func (s *Drop_file_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_file_format(s) + } +} + +func (s *Drop_file_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_file_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_file_format() (localctx IDrop_file_formatContext) { + localctx = NewDrop_file_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 568, SnowflakeParserRULE_drop_file_format) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9293) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9294) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9295) + p.Match(SnowflakeParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9297) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1178, p.GetParserRuleContext()) == 1 { + { + p.SetState(9296) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9299) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_functionContext is an interface to support dynamic dispatch. +type IDrop_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Object_name() IObject_nameContext + Arg_types() IArg_typesContext + If_exists() IIf_existsContext + + // IsDrop_functionContext differentiates from other interfaces. + IsDrop_functionContext() +} + +type Drop_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_functionContext() *Drop_functionContext { + var p = new(Drop_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_function + return p +} + +func InitEmptyDrop_functionContext(p *Drop_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_function +} + +func (*Drop_functionContext) IsDrop_functionContext() {} + +func NewDrop_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_functionContext { + var p = new(Drop_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_function + + return p +} + +func (s *Drop_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_functionContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Drop_functionContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_functionContext) Arg_types() IArg_typesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_typesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArg_typesContext) +} + +func (s *Drop_functionContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_function(s) + } +} + +func (s *Drop_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_function(s) + } +} + +func (s *Drop_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_function() (localctx IDrop_functionContext) { + localctx = NewDrop_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 570, SnowflakeParserRULE_drop_function) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9301) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9302) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9304) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1179, p.GetParserRuleContext()) == 1 { + { + p.SetState(9303) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9306) + p.Object_name() + } + { + p.SetState(9307) + p.Arg_types() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_integrationContext is an interface to support dynamic dispatch. +type IDrop_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + API() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + SECURITY() antlr.TerminalNode + STORAGE() antlr.TerminalNode + + // IsDrop_integrationContext differentiates from other interfaces. + IsDrop_integrationContext() +} + +type Drop_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_integrationContext() *Drop_integrationContext { + var p = new(Drop_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_integration + return p +} + +func InitEmptyDrop_integrationContext(p *Drop_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_integration +} + +func (*Drop_integrationContext) IsDrop_integrationContext() {} + +func NewDrop_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_integrationContext { + var p = new(Drop_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_integration + + return p +} + +func (s *Drop_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_integrationContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_integrationContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Drop_integrationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_integrationContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_integrationContext) API() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI, 0) +} + +func (s *Drop_integrationContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION, 0) +} + +func (s *Drop_integrationContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Drop_integrationContext) STORAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE, 0) +} + +func (s *Drop_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_integration(s) + } +} + +func (s *Drop_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_integration(s) + } +} + +func (s *Drop_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_integration() (localctx IDrop_integrationContext) { + localctx = NewDrop_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 572, SnowflakeParserRULE_drop_integration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9309) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI || _la == SnowflakeParserNOTIFICATION || _la == SnowflakeParserSECURITY || _la == SnowflakeParserSTORAGE { + { + p.SetState(9310) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAPI || _la == SnowflakeParserNOTIFICATION || _la == SnowflakeParserSECURITY || _la == SnowflakeParserSTORAGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(9313) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9315) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1181, p.GetParserRuleContext()) == 1 { + { + p.SetState(9314) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9317) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_managed_accountContext is an interface to support dynamic dispatch. +type IDrop_managed_accountContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MANAGED() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_managed_accountContext differentiates from other interfaces. + IsDrop_managed_accountContext() +} + +type Drop_managed_accountContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_managed_accountContext() *Drop_managed_accountContext { + var p = new(Drop_managed_accountContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_managed_account + return p +} + +func InitEmptyDrop_managed_accountContext(p *Drop_managed_accountContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_managed_account +} + +func (*Drop_managed_accountContext) IsDrop_managed_accountContext() {} + +func NewDrop_managed_accountContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_managed_accountContext { + var p = new(Drop_managed_accountContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_managed_account + + return p +} + +func (s *Drop_managed_accountContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_managed_accountContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_managed_accountContext) MANAGED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMANAGED, 0) +} + +func (s *Drop_managed_accountContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Drop_managed_accountContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_managed_accountContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_managed_accountContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_managed_accountContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_managed_account(s) + } +} + +func (s *Drop_managed_accountContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_managed_account(s) + } +} + +func (s *Drop_managed_accountContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_managed_account(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_managed_account() (localctx IDrop_managed_accountContext) { + localctx = NewDrop_managed_accountContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 574, SnowflakeParserRULE_drop_managed_account) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9319) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9320) + p.Match(SnowflakeParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9321) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9322) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_masking_policyContext is an interface to support dynamic dispatch. +type IDrop_masking_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_masking_policyContext differentiates from other interfaces. + IsDrop_masking_policyContext() +} + +type Drop_masking_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_masking_policyContext() *Drop_masking_policyContext { + var p = new(Drop_masking_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_masking_policy + return p +} + +func InitEmptyDrop_masking_policyContext(p *Drop_masking_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_masking_policy +} + +func (*Drop_masking_policyContext) IsDrop_masking_policyContext() {} + +func NewDrop_masking_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_masking_policyContext { + var p = new(Drop_masking_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_masking_policy + + return p +} + +func (s *Drop_masking_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_masking_policyContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_masking_policyContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Drop_masking_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Drop_masking_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_masking_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_masking_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_masking_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_masking_policy(s) + } +} + +func (s *Drop_masking_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_masking_policy(s) + } +} + +func (s *Drop_masking_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_masking_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_masking_policy() (localctx IDrop_masking_policyContext) { + localctx = NewDrop_masking_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 576, SnowflakeParserRULE_drop_masking_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9324) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9325) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9326) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9327) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_materialized_viewContext is an interface to support dynamic dispatch. +type IDrop_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + + // IsDrop_materialized_viewContext differentiates from other interfaces. + IsDrop_materialized_viewContext() +} + +type Drop_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_materialized_viewContext() *Drop_materialized_viewContext { + var p = new(Drop_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_materialized_view + return p +} + +func InitEmptyDrop_materialized_viewContext(p *Drop_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_materialized_view +} + +func (*Drop_materialized_viewContext) IsDrop_materialized_viewContext() {} + +func NewDrop_materialized_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_materialized_viewContext { + var p = new(Drop_materialized_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_materialized_view + + return p +} + +func (s *Drop_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_materialized_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATERIALIZED, 0) +} + +func (s *Drop_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Drop_materialized_viewContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_materialized_viewContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_materialized_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_materialized_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_materialized_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_materialized_view(s) + } +} + +func (s *Drop_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_materialized_view(s) + } +} + +func (s *Drop_materialized_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_materialized_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_materialized_view() (localctx IDrop_materialized_viewContext) { + localctx = NewDrop_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 578, SnowflakeParserRULE_drop_materialized_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9329) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9330) + p.Match(SnowflakeParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9331) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9333) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1182, p.GetParserRuleContext()) == 1 { + { + p.SetState(9332) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9335) + p.Object_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 +} + +// IDrop_network_policyContext is an interface to support dynamic dispatch. +type IDrop_network_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + NETWORK() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_network_policyContext differentiates from other interfaces. + IsDrop_network_policyContext() +} + +type Drop_network_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_network_policyContext() *Drop_network_policyContext { + var p = new(Drop_network_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_network_policy + return p +} + +func InitEmptyDrop_network_policyContext(p *Drop_network_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_network_policy +} + +func (*Drop_network_policyContext) IsDrop_network_policyContext() {} + +func NewDrop_network_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_network_policyContext { + var p = new(Drop_network_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_network_policy + + return p +} + +func (s *Drop_network_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_network_policyContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_network_policyContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Drop_network_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Drop_network_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_network_policyContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_network_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_network_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_network_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_network_policy(s) + } +} + +func (s *Drop_network_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_network_policy(s) + } +} + +func (s *Drop_network_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_network_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_network_policy() (localctx IDrop_network_policyContext) { + localctx = NewDrop_network_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 580, SnowflakeParserRULE_drop_network_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9337) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9338) + p.Match(SnowflakeParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9339) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9341) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1183, p.GetParserRuleContext()) == 1 { + { + p.SetState(9340) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9343) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_pipeContext is an interface to support dynamic dispatch. +type IDrop_pipeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + PIPE() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + + // IsDrop_pipeContext differentiates from other interfaces. + IsDrop_pipeContext() +} + +type Drop_pipeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_pipeContext() *Drop_pipeContext { + var p = new(Drop_pipeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_pipe + return p +} + +func InitEmptyDrop_pipeContext(p *Drop_pipeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_pipe +} + +func (*Drop_pipeContext) IsDrop_pipeContext() {} + +func NewDrop_pipeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_pipeContext { + var p = new(Drop_pipeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_pipe + + return p +} + +func (s *Drop_pipeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_pipeContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_pipeContext) PIPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE, 0) +} + +func (s *Drop_pipeContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_pipeContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_pipeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_pipeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_pipeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_pipe(s) + } +} + +func (s *Drop_pipeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_pipe(s) + } +} + +func (s *Drop_pipeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_pipe(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_pipe() (localctx IDrop_pipeContext) { + localctx = NewDrop_pipeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 582, SnowflakeParserRULE_drop_pipe) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9345) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9346) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9348) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1184, p.GetParserRuleContext()) == 1 { + { + p.SetState(9347) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9350) + p.Object_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 +} + +// IDrop_procedureContext is an interface to support dynamic dispatch. +type IDrop_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + Object_name() IObject_nameContext + Arg_types() IArg_typesContext + If_exists() IIf_existsContext + + // IsDrop_procedureContext differentiates from other interfaces. + IsDrop_procedureContext() +} + +type Drop_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_procedureContext() *Drop_procedureContext { + var p = new(Drop_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_procedure + return p +} + +func InitEmptyDrop_procedureContext(p *Drop_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_procedure +} + +func (*Drop_procedureContext) IsDrop_procedureContext() {} + +func NewDrop_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_procedureContext { + var p = new(Drop_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_procedure + + return p +} + +func (s *Drop_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_procedureContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE, 0) +} + +func (s *Drop_procedureContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_procedureContext) Arg_types() IArg_typesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_typesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArg_typesContext) +} + +func (s *Drop_procedureContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_procedure(s) + } +} + +func (s *Drop_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_procedure(s) + } +} + +func (s *Drop_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_procedure() (localctx IDrop_procedureContext) { + localctx = NewDrop_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 584, SnowflakeParserRULE_drop_procedure) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9352) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9353) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9355) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1185, p.GetParserRuleContext()) == 1 { + { + p.SetState(9354) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9357) + p.Object_name() + } + { + p.SetState(9358) + p.Arg_types() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_replication_groupContext is an interface to support dynamic dispatch. +type IDrop_replication_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_replication_groupContext differentiates from other interfaces. + IsDrop_replication_groupContext() +} + +type Drop_replication_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_replication_groupContext() *Drop_replication_groupContext { + var p = new(Drop_replication_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_replication_group + return p +} + +func InitEmptyDrop_replication_groupContext(p *Drop_replication_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_replication_group +} + +func (*Drop_replication_groupContext) IsDrop_replication_groupContext() {} + +func NewDrop_replication_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_replication_groupContext { + var p = new(Drop_replication_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_replication_group + + return p +} + +func (s *Drop_replication_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_replication_groupContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_replication_groupContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Drop_replication_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Drop_replication_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_replication_groupContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_replication_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_replication_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_replication_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_replication_group(s) + } +} + +func (s *Drop_replication_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_replication_group(s) + } +} + +func (s *Drop_replication_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_replication_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_replication_group() (localctx IDrop_replication_groupContext) { + localctx = NewDrop_replication_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 586, SnowflakeParserRULE_drop_replication_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9360) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9361) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9362) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9364) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1186, p.GetParserRuleContext()) == 1 { + { + p.SetState(9363) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9366) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_resource_monitorContext is an interface to support dynamic dispatch. +type IDrop_resource_monitorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + MONITOR() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_resource_monitorContext differentiates from other interfaces. + IsDrop_resource_monitorContext() +} + +type Drop_resource_monitorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_resource_monitorContext() *Drop_resource_monitorContext { + var p = new(Drop_resource_monitorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_resource_monitor + return p +} + +func InitEmptyDrop_resource_monitorContext(p *Drop_resource_monitorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_resource_monitor +} + +func (*Drop_resource_monitorContext) IsDrop_resource_monitorContext() {} + +func NewDrop_resource_monitorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_resource_monitorContext { + var p = new(Drop_resource_monitorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_resource_monitor + + return p +} + +func (s *Drop_resource_monitorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_resource_monitorContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_resource_monitorContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE, 0) +} + +func (s *Drop_resource_monitorContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Drop_resource_monitorContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_resource_monitorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_resource_monitorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_resource_monitorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_resource_monitor(s) + } +} + +func (s *Drop_resource_monitorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_resource_monitor(s) + } +} + +func (s *Drop_resource_monitorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_resource_monitor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_resource_monitor() (localctx IDrop_resource_monitorContext) { + localctx = NewDrop_resource_monitorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 588, SnowflakeParserRULE_drop_resource_monitor) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9368) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9369) + p.Match(SnowflakeParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9370) + p.Match(SnowflakeParserMONITOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9371) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_roleContext is an interface to support dynamic dispatch. +type IDrop_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + ROLE() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_roleContext differentiates from other interfaces. + IsDrop_roleContext() +} + +type Drop_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_roleContext() *Drop_roleContext { + var p = new(Drop_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_role + return p +} + +func InitEmptyDrop_roleContext(p *Drop_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_role +} + +func (*Drop_roleContext) IsDrop_roleContext() {} + +func NewDrop_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_roleContext { + var p = new(Drop_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_role + + return p +} + +func (s *Drop_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_roleContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Drop_roleContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_roleContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_role(s) + } +} + +func (s *Drop_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_role(s) + } +} + +func (s *Drop_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_role() (localctx IDrop_roleContext) { + localctx = NewDrop_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 590, SnowflakeParserRULE_drop_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9373) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9374) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9376) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1187, p.GetParserRuleContext()) == 1 { + { + p.SetState(9375) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9378) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_row_access_policyContext is an interface to support dynamic dispatch. +type IDrop_row_access_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_row_access_policyContext differentiates from other interfaces. + IsDrop_row_access_policyContext() +} + +type Drop_row_access_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_row_access_policyContext() *Drop_row_access_policyContext { + var p = new(Drop_row_access_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_row_access_policy + return p +} + +func InitEmptyDrop_row_access_policyContext(p *Drop_row_access_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_row_access_policy +} + +func (*Drop_row_access_policyContext) IsDrop_row_access_policyContext() {} + +func NewDrop_row_access_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_row_access_policyContext { + var p = new(Drop_row_access_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_row_access_policy + + return p +} + +func (s *Drop_row_access_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_row_access_policyContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_row_access_policyContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Drop_row_access_policyContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Drop_row_access_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Drop_row_access_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_row_access_policyContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_row_access_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_row_access_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_row_access_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_row_access_policy(s) + } +} + +func (s *Drop_row_access_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_row_access_policy(s) + } +} + +func (s *Drop_row_access_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_row_access_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_row_access_policy() (localctx IDrop_row_access_policyContext) { + localctx = NewDrop_row_access_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 592, SnowflakeParserRULE_drop_row_access_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9380) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9381) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9382) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9383) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9385) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1188, p.GetParserRuleContext()) == 1 { + { + p.SetState(9384) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9387) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_schemaContext is an interface to support dynamic dispatch. +type IDrop_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + If_exists() IIf_existsContext + Cascade_restrict() ICascade_restrictContext + + // IsDrop_schemaContext differentiates from other interfaces. + IsDrop_schemaContext() +} + +type Drop_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_schemaContext() *Drop_schemaContext { + var p = new(Drop_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_schema + return p +} + +func InitEmptyDrop_schemaContext(p *Drop_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_schema +} + +func (*Drop_schemaContext) IsDrop_schemaContext() {} + +func NewDrop_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_schemaContext { + var p = new(Drop_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_schema + + return p +} + +func (s *Drop_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_schemaContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_schemaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Drop_schemaContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Drop_schemaContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_schemaContext) Cascade_restrict() ICascade_restrictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICascade_restrictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICascade_restrictContext) +} + +func (s *Drop_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_schema(s) + } +} + +func (s *Drop_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_schema(s) + } +} + +func (s *Drop_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_schema() (localctx IDrop_schemaContext) { + localctx = NewDrop_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 594, SnowflakeParserRULE_drop_schema) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9389) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9390) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9392) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1189, p.GetParserRuleContext()) == 1 { + { + p.SetState(9391) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9394) + p.Schema_name() + } + p.SetState(9396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT { + { + p.SetState(9395) + p.Cascade_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 +} + +// IDrop_sequenceContext is an interface to support dynamic dispatch. +type IDrop_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + Cascade_restrict() ICascade_restrictContext + + // IsDrop_sequenceContext differentiates from other interfaces. + IsDrop_sequenceContext() +} + +type Drop_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_sequenceContext() *Drop_sequenceContext { + var p = new(Drop_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_sequence + return p +} + +func InitEmptyDrop_sequenceContext(p *Drop_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_sequence +} + +func (*Drop_sequenceContext) IsDrop_sequenceContext() {} + +func NewDrop_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_sequenceContext { + var p = new(Drop_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_sequence + + return p +} + +func (s *Drop_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_sequenceContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 0) +} + +func (s *Drop_sequenceContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_sequenceContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_sequenceContext) Cascade_restrict() ICascade_restrictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICascade_restrictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICascade_restrictContext) +} + +func (s *Drop_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_sequence(s) + } +} + +func (s *Drop_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_sequence(s) + } +} + +func (s *Drop_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_sequence() (localctx IDrop_sequenceContext) { + localctx = NewDrop_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 596, SnowflakeParserRULE_drop_sequence) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9398) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9399) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9401) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1191, p.GetParserRuleContext()) == 1 { + { + p.SetState(9400) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9403) + p.Object_name() + } + p.SetState(9405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT { + { + p.SetState(9404) + p.Cascade_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 +} + +// IDrop_session_policyContext is an interface to support dynamic dispatch. +type IDrop_session_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SESSION() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_session_policyContext differentiates from other interfaces. + IsDrop_session_policyContext() +} + +type Drop_session_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_session_policyContext() *Drop_session_policyContext { + var p = new(Drop_session_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_session_policy + return p +} + +func InitEmptyDrop_session_policyContext(p *Drop_session_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_session_policy +} + +func (*Drop_session_policyContext) IsDrop_session_policyContext() {} + +func NewDrop_session_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_session_policyContext { + var p = new(Drop_session_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_session_policy + + return p +} + +func (s *Drop_session_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_session_policyContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_session_policyContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Drop_session_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Drop_session_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_session_policyContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_session_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_session_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_session_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_session_policy(s) + } +} + +func (s *Drop_session_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_session_policy(s) + } +} + +func (s *Drop_session_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_session_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_session_policy() (localctx IDrop_session_policyContext) { + localctx = NewDrop_session_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 598, SnowflakeParserRULE_drop_session_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9407) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9408) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9409) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9411) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1193, p.GetParserRuleContext()) == 1 { + { + p.SetState(9410) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9413) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_shareContext is an interface to support dynamic dispatch. +type IDrop_shareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SHARE() antlr.TerminalNode + Id_() IId_Context + + // IsDrop_shareContext differentiates from other interfaces. + IsDrop_shareContext() +} + +type Drop_shareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_shareContext() *Drop_shareContext { + var p = new(Drop_shareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_share + return p +} + +func InitEmptyDrop_shareContext(p *Drop_shareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_share +} + +func (*Drop_shareContext) IsDrop_shareContext() {} + +func NewDrop_shareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_shareContext { + var p = new(Drop_shareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_share + + return p +} + +func (s *Drop_shareContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_shareContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_shareContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Drop_shareContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_shareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_shareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_shareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_share(s) + } +} + +func (s *Drop_shareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_share(s) + } +} + +func (s *Drop_shareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_share(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_share() (localctx IDrop_shareContext) { + localctx = NewDrop_shareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 600, SnowflakeParserRULE_drop_share) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9415) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9416) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9417) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_stageContext is an interface to support dynamic dispatch. +type IDrop_stageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + STAGE() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + + // IsDrop_stageContext differentiates from other interfaces. + IsDrop_stageContext() +} + +type Drop_stageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_stageContext() *Drop_stageContext { + var p = new(Drop_stageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_stage + return p +} + +func InitEmptyDrop_stageContext(p *Drop_stageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_stage +} + +func (*Drop_stageContext) IsDrop_stageContext() {} + +func NewDrop_stageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_stageContext { + var p = new(Drop_stageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_stage + + return p +} + +func (s *Drop_stageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_stageContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_stageContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Drop_stageContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_stageContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_stageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_stageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_stageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_stage(s) + } +} + +func (s *Drop_stageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_stage(s) + } +} + +func (s *Drop_stageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_stage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_stage() (localctx IDrop_stageContext) { + localctx = NewDrop_stageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 602, SnowflakeParserRULE_drop_stage) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9419) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9420) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9422) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1194, p.GetParserRuleContext()) == 1 { + { + p.SetState(9421) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9424) + p.Object_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 +} + +// IDrop_streamContext is an interface to support dynamic dispatch. +type IDrop_streamContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + STREAM() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + + // IsDrop_streamContext differentiates from other interfaces. + IsDrop_streamContext() +} + +type Drop_streamContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_streamContext() *Drop_streamContext { + var p = new(Drop_streamContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_stream + return p +} + +func InitEmptyDrop_streamContext(p *Drop_streamContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_stream +} + +func (*Drop_streamContext) IsDrop_streamContext() {} + +func NewDrop_streamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_streamContext { + var p = new(Drop_streamContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_stream + + return p +} + +func (s *Drop_streamContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_streamContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_streamContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Drop_streamContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_streamContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_streamContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_streamContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_streamContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_stream(s) + } +} + +func (s *Drop_streamContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_stream(s) + } +} + +func (s *Drop_streamContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_stream(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_stream() (localctx IDrop_streamContext) { + localctx = NewDrop_streamContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 604, SnowflakeParserRULE_drop_stream) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9426) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9427) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9429) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1195, p.GetParserRuleContext()) == 1 { + { + p.SetState(9428) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9431) + p.Object_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 +} + +// IDrop_tableContext is an interface to support dynamic dispatch. +type IDrop_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + Cascade_restrict() ICascade_restrictContext + + // IsDrop_tableContext differentiates from other interfaces. + IsDrop_tableContext() +} + +type Drop_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_tableContext() *Drop_tableContext { + var p = new(Drop_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_table + return p +} + +func InitEmptyDrop_tableContext(p *Drop_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_table +} + +func (*Drop_tableContext) IsDrop_tableContext() {} + +func NewDrop_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tableContext { + var p = new(Drop_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_table + + return p +} + +func (s *Drop_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Drop_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_tableContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_tableContext) Cascade_restrict() ICascade_restrictContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICascade_restrictContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICascade_restrictContext) +} + +func (s *Drop_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_table(s) + } +} + +func (s *Drop_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_table(s) + } +} + +func (s *Drop_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_table() (localctx IDrop_tableContext) { + localctx = NewDrop_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 606, SnowflakeParserRULE_drop_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9433) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9434) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9436) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1196, p.GetParserRuleContext()) == 1 { + { + p.SetState(9435) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9438) + p.Object_name() + } + p.SetState(9440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT { + { + p.SetState(9439) + p.Cascade_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 +} + +// IDrop_tagContext is an interface to support dynamic dispatch. +type IDrop_tagContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TAG() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_tagContext differentiates from other interfaces. + IsDrop_tagContext() +} + +type Drop_tagContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_tagContext() *Drop_tagContext { + var p = new(Drop_tagContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_tag + return p +} + +func InitEmptyDrop_tagContext(p *Drop_tagContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_tag +} + +func (*Drop_tagContext) IsDrop_tagContext() {} + +func NewDrop_tagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tagContext { + var p = new(Drop_tagContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_tag + + return p +} + +func (s *Drop_tagContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tagContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_tagContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Drop_tagContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_tagContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_tagContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_tagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_tagContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_tag(s) + } +} + +func (s *Drop_tagContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_tag(s) + } +} + +func (s *Drop_tagContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_tag(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_tag() (localctx IDrop_tagContext) { + localctx = NewDrop_tagContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 608, SnowflakeParserRULE_drop_tag) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9442) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9443) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9445) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1198, p.GetParserRuleContext()) == 1 { + { + p.SetState(9444) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9447) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_taskContext is an interface to support dynamic dispatch. +type IDrop_taskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TASK() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + + // IsDrop_taskContext differentiates from other interfaces. + IsDrop_taskContext() +} + +type Drop_taskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_taskContext() *Drop_taskContext { + var p = new(Drop_taskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_task + return p +} + +func InitEmptyDrop_taskContext(p *Drop_taskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_task +} + +func (*Drop_taskContext) IsDrop_taskContext() {} + +func NewDrop_taskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_taskContext { + var p = new(Drop_taskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_task + + return p +} + +func (s *Drop_taskContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_taskContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_taskContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Drop_taskContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_taskContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_taskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_taskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_taskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_task(s) + } +} + +func (s *Drop_taskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_task(s) + } +} + +func (s *Drop_taskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_task(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_task() (localctx IDrop_taskContext) { + localctx = NewDrop_taskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 610, SnowflakeParserRULE_drop_task) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9449) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9450) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9452) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1199, p.GetParserRuleContext()) == 1 { + { + p.SetState(9451) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9454) + p.Object_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 +} + +// IDrop_userContext is an interface to support dynamic dispatch. +type IDrop_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + USER() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_userContext differentiates from other interfaces. + IsDrop_userContext() +} + +type Drop_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_userContext() *Drop_userContext { + var p = new(Drop_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_user + return p +} + +func InitEmptyDrop_userContext(p *Drop_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_user +} + +func (*Drop_userContext) IsDrop_userContext() {} + +func NewDrop_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_userContext { + var p = new(Drop_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_user + + return p +} + +func (s *Drop_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_userContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_userContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Drop_userContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_userContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_user(s) + } +} + +func (s *Drop_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_user(s) + } +} + +func (s *Drop_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_user() (localctx IDrop_userContext) { + localctx = NewDrop_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 612, SnowflakeParserRULE_drop_user) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9456) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9457) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9459) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1200, p.GetParserRuleContext()) == 1 { + { + p.SetState(9458) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9461) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_viewContext is an interface to support dynamic dispatch. +type IDrop_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + VIEW() antlr.TerminalNode + Object_name() IObject_nameContext + If_exists() IIf_existsContext + + // IsDrop_viewContext differentiates from other interfaces. + IsDrop_viewContext() +} + +type Drop_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_viewContext() *Drop_viewContext { + var p = new(Drop_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_view + return p +} + +func InitEmptyDrop_viewContext(p *Drop_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_view +} + +func (*Drop_viewContext) IsDrop_viewContext() {} + +func NewDrop_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_viewContext { + var p = new(Drop_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_view + + return p +} + +func (s *Drop_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Drop_viewContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Drop_viewContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_view(s) + } +} + +func (s *Drop_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_view(s) + } +} + +func (s *Drop_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_view() (localctx IDrop_viewContext) { + localctx = NewDrop_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 614, SnowflakeParserRULE_drop_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9463) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9464) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9466) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1201, p.GetParserRuleContext()) == 1 { + { + p.SetState(9465) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9468) + p.Object_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 +} + +// IDrop_warehouseContext is an interface to support dynamic dispatch. +type IDrop_warehouseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + Id_() IId_Context + If_exists() IIf_existsContext + + // IsDrop_warehouseContext differentiates from other interfaces. + IsDrop_warehouseContext() +} + +type Drop_warehouseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_warehouseContext() *Drop_warehouseContext { + var p = new(Drop_warehouseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_warehouse + return p +} + +func InitEmptyDrop_warehouseContext(p *Drop_warehouseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_drop_warehouse +} + +func (*Drop_warehouseContext) IsDrop_warehouseContext() {} + +func NewDrop_warehouseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_warehouseContext { + var p = new(Drop_warehouseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_drop_warehouse + + return p +} + +func (s *Drop_warehouseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_warehouseContext) DROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDROP, 0) +} + +func (s *Drop_warehouseContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Drop_warehouseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Drop_warehouseContext) If_exists() IIf_existsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_existsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_existsContext) +} + +func (s *Drop_warehouseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_warehouseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_warehouseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDrop_warehouse(s) + } +} + +func (s *Drop_warehouseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDrop_warehouse(s) + } +} + +func (s *Drop_warehouseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDrop_warehouse(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Drop_warehouse() (localctx IDrop_warehouseContext) { + localctx = NewDrop_warehouseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 616, SnowflakeParserRULE_drop_warehouse) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9470) + p.Match(SnowflakeParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9471) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9473) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1202, p.GetParserRuleContext()) == 1 { + { + p.SetState(9472) + p.If_exists() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9475) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICascade_restrictContext is an interface to support dynamic dispatch. +type ICascade_restrictContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CASCADE() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + + // IsCascade_restrictContext differentiates from other interfaces. + IsCascade_restrictContext() +} + +type Cascade_restrictContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCascade_restrictContext() *Cascade_restrictContext { + var p = new(Cascade_restrictContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cascade_restrict + return p +} + +func InitEmptyCascade_restrictContext(p *Cascade_restrictContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_cascade_restrict +} + +func (*Cascade_restrictContext) IsCascade_restrictContext() {} + +func NewCascade_restrictContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cascade_restrictContext { + var p = new(Cascade_restrictContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_cascade_restrict + + return p +} + +func (s *Cascade_restrictContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cascade_restrictContext) CASCADE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCASCADE, 0) +} + +func (s *Cascade_restrictContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESTRICT, 0) +} + +func (s *Cascade_restrictContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cascade_restrictContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cascade_restrictContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCascade_restrict(s) + } +} + +func (s *Cascade_restrictContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCascade_restrict(s) + } +} + +func (s *Cascade_restrictContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCascade_restrict(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Cascade_restrict() (localctx ICascade_restrictContext) { + localctx = NewCascade_restrictContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 618, SnowflakeParserRULE_cascade_restrict) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9477) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCASCADE || _la == SnowflakeParserRESTRICT) { + 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 +} + +// IArg_typesContext is an interface to support dynamic dispatch. +type IArg_typesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Data_type_list() IData_type_listContext + + // IsArg_typesContext differentiates from other interfaces. + IsArg_typesContext() +} + +type Arg_typesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArg_typesContext() *Arg_typesContext { + var p = new(Arg_typesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arg_types + return p +} + +func InitEmptyArg_typesContext(p *Arg_typesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arg_types +} + +func (*Arg_typesContext) IsArg_typesContext() {} + +func NewArg_typesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arg_typesContext { + var p = new(Arg_typesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_arg_types + + return p +} + +func (s *Arg_typesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Arg_typesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Arg_typesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Arg_typesContext) Data_type_list() IData_type_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_type_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_type_listContext) +} + +func (s *Arg_typesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Arg_typesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Arg_typesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterArg_types(s) + } +} + +func (s *Arg_typesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitArg_types(s) + } +} + +func (s *Arg_typesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitArg_types(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Arg_types() (localctx IArg_typesContext) { + localctx = NewArg_typesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 620, SnowflakeParserRULE_arg_types) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9479) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCHAR || _la == SnowflakeParserCHARACTER || _la == SnowflakeParserDOUBLE || _la == SnowflakeParserINT || _la == SnowflakeParserNUMBER || _la == SnowflakeParserOBJECT || ((int64((_la-899)) & ^0x3f) == 0 && ((int64(1)<<(_la-899))&35361) != 0) || ((int64((_la-1039)) & ^0x3f) == 0 && ((int64(1)<<(_la-1039))&267583421) != 0) { + { + p.SetState(9480) + p.Data_type_list() + } + + } + { + p.SetState(9483) + p.Match(SnowflakeParserRR_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 +} + +// IUndrop_commandContext is an interface to support dynamic dispatch. +type IUndrop_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Undrop_database() IUndrop_databaseContext + Undrop_dynamic_table() IUndrop_dynamic_tableContext + Undrop_schema() IUndrop_schemaContext + Undrop_table() IUndrop_tableContext + Undrop_tag() IUndrop_tagContext + + // IsUndrop_commandContext differentiates from other interfaces. + IsUndrop_commandContext() +} + +type Undrop_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_commandContext() *Undrop_commandContext { + var p = new(Undrop_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_command + return p +} + +func InitEmptyUndrop_commandContext(p *Undrop_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_command +} + +func (*Undrop_commandContext) IsUndrop_commandContext() {} + +func NewUndrop_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_commandContext { + var p = new(Undrop_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_undrop_command + + return p +} + +func (s *Undrop_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_commandContext) Undrop_database() IUndrop_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_databaseContext) +} + +func (s *Undrop_commandContext) Undrop_dynamic_table() IUndrop_dynamic_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_dynamic_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_dynamic_tableContext) +} + +func (s *Undrop_commandContext) Undrop_schema() IUndrop_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_schemaContext) +} + +func (s *Undrop_commandContext) Undrop_table() IUndrop_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_tableContext) +} + +func (s *Undrop_commandContext) Undrop_tag() IUndrop_tagContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_tagContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_tagContext) +} + +func (s *Undrop_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUndrop_command(s) + } +} + +func (s *Undrop_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUndrop_command(s) + } +} + +func (s *Undrop_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUndrop_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Undrop_command() (localctx IUndrop_commandContext) { + localctx = NewUndrop_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 622, SnowflakeParserRULE_undrop_command) + p.SetState(9490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1204, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9485) + p.Undrop_database() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9486) + p.Undrop_dynamic_table() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9487) + p.Undrop_schema() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9488) + p.Undrop_table() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9489) + p.Undrop_tag() + } + + 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 +} + +// IUndrop_databaseContext is an interface to support dynamic dispatch. +type IUndrop_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + + // IsUndrop_databaseContext differentiates from other interfaces. + IsUndrop_databaseContext() +} + +type Undrop_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_databaseContext() *Undrop_databaseContext { + var p = new(Undrop_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_database + return p +} + +func InitEmptyUndrop_databaseContext(p *Undrop_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_database +} + +func (*Undrop_databaseContext) IsUndrop_databaseContext() {} + +func NewUndrop_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_databaseContext { + var p = new(Undrop_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_undrop_database + + return p +} + +func (s *Undrop_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_databaseContext) UNDROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNDROP, 0) +} + +func (s *Undrop_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Undrop_databaseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Undrop_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUndrop_database(s) + } +} + +func (s *Undrop_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUndrop_database(s) + } +} + +func (s *Undrop_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUndrop_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Undrop_database() (localctx IUndrop_databaseContext) { + localctx = NewUndrop_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 624, SnowflakeParserRULE_undrop_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9492) + p.Match(SnowflakeParserUNDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9493) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9494) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUndrop_dynamic_tableContext is an interface to support dynamic dispatch. +type IUndrop_dynamic_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDROP() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + TABLE() antlr.TerminalNode + Id_() IId_Context + + // IsUndrop_dynamic_tableContext differentiates from other interfaces. + IsUndrop_dynamic_tableContext() +} + +type Undrop_dynamic_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_dynamic_tableContext() *Undrop_dynamic_tableContext { + var p = new(Undrop_dynamic_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_dynamic_table + return p +} + +func InitEmptyUndrop_dynamic_tableContext(p *Undrop_dynamic_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_dynamic_table +} + +func (*Undrop_dynamic_tableContext) IsUndrop_dynamic_tableContext() {} + +func NewUndrop_dynamic_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_dynamic_tableContext { + var p = new(Undrop_dynamic_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_undrop_dynamic_table + + return p +} + +func (s *Undrop_dynamic_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_dynamic_tableContext) UNDROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNDROP, 0) +} + +func (s *Undrop_dynamic_tableContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDYNAMIC, 0) +} + +func (s *Undrop_dynamic_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Undrop_dynamic_tableContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Undrop_dynamic_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_dynamic_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_dynamic_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUndrop_dynamic_table(s) + } +} + +func (s *Undrop_dynamic_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUndrop_dynamic_table(s) + } +} + +func (s *Undrop_dynamic_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUndrop_dynamic_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Undrop_dynamic_table() (localctx IUndrop_dynamic_tableContext) { + localctx = NewUndrop_dynamic_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 626, SnowflakeParserRULE_undrop_dynamic_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9496) + p.Match(SnowflakeParserUNDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9497) + p.Match(SnowflakeParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9498) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9499) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUndrop_schemaContext is an interface to support dynamic dispatch. +type IUndrop_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDROP() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsUndrop_schemaContext differentiates from other interfaces. + IsUndrop_schemaContext() +} + +type Undrop_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_schemaContext() *Undrop_schemaContext { + var p = new(Undrop_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_schema + return p +} + +func InitEmptyUndrop_schemaContext(p *Undrop_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_schema +} + +func (*Undrop_schemaContext) IsUndrop_schemaContext() {} + +func NewUndrop_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_schemaContext { + var p = new(Undrop_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_undrop_schema + + return p +} + +func (s *Undrop_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_schemaContext) UNDROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNDROP, 0) +} + +func (s *Undrop_schemaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Undrop_schemaContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Undrop_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUndrop_schema(s) + } +} + +func (s *Undrop_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUndrop_schema(s) + } +} + +func (s *Undrop_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUndrop_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Undrop_schema() (localctx IUndrop_schemaContext) { + localctx = NewUndrop_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 628, SnowflakeParserRULE_undrop_schema) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9501) + p.Match(SnowflakeParserUNDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9502) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9503) + p.Schema_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 +} + +// IUndrop_tableContext is an interface to support dynamic dispatch. +type IUndrop_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDROP() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsUndrop_tableContext differentiates from other interfaces. + IsUndrop_tableContext() +} + +type Undrop_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_tableContext() *Undrop_tableContext { + var p = new(Undrop_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_table + return p +} + +func InitEmptyUndrop_tableContext(p *Undrop_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_table +} + +func (*Undrop_tableContext) IsUndrop_tableContext() {} + +func NewUndrop_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_tableContext { + var p = new(Undrop_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_undrop_table + + return p +} + +func (s *Undrop_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_tableContext) UNDROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNDROP, 0) +} + +func (s *Undrop_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Undrop_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Undrop_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUndrop_table(s) + } +} + +func (s *Undrop_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUndrop_table(s) + } +} + +func (s *Undrop_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUndrop_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Undrop_table() (localctx IUndrop_tableContext) { + localctx = NewUndrop_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 630, SnowflakeParserRULE_undrop_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9505) + p.Match(SnowflakeParserUNDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9506) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9507) + p.Object_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 +} + +// IUndrop_tagContext is an interface to support dynamic dispatch. +type IUndrop_tagContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDROP() antlr.TerminalNode + TAG() antlr.TerminalNode + Id_() IId_Context + + // IsUndrop_tagContext differentiates from other interfaces. + IsUndrop_tagContext() +} + +type Undrop_tagContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_tagContext() *Undrop_tagContext { + var p = new(Undrop_tagContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_tag + return p +} + +func InitEmptyUndrop_tagContext(p *Undrop_tagContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_undrop_tag +} + +func (*Undrop_tagContext) IsUndrop_tagContext() {} + +func NewUndrop_tagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_tagContext { + var p = new(Undrop_tagContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_undrop_tag + + return p +} + +func (s *Undrop_tagContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_tagContext) UNDROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNDROP, 0) +} + +func (s *Undrop_tagContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Undrop_tagContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Undrop_tagContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_tagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_tagContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUndrop_tag(s) + } +} + +func (s *Undrop_tagContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUndrop_tag(s) + } +} + +func (s *Undrop_tagContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUndrop_tag(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Undrop_tag() (localctx IUndrop_tagContext) { + localctx = NewUndrop_tagContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 632, SnowflakeParserRULE_undrop_tag) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9509) + p.Match(SnowflakeParserUNDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9510) + p.Match(SnowflakeParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9511) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUse_commandContext is an interface to support dynamic dispatch. +type IUse_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Use_database() IUse_databaseContext + Use_role() IUse_roleContext + Use_schema() IUse_schemaContext + Use_secondary_roles() IUse_secondary_rolesContext + Use_warehouse() IUse_warehouseContext + + // IsUse_commandContext differentiates from other interfaces. + IsUse_commandContext() +} + +type Use_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUse_commandContext() *Use_commandContext { + var p = new(Use_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_command + return p +} + +func InitEmptyUse_commandContext(p *Use_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_command +} + +func (*Use_commandContext) IsUse_commandContext() {} + +func NewUse_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_commandContext { + var p = new(Use_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_use_command + + return p +} + +func (s *Use_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_commandContext) Use_database() IUse_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_databaseContext) +} + +func (s *Use_commandContext) Use_role() IUse_roleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_roleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_roleContext) +} + +func (s *Use_commandContext) Use_schema() IUse_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_schemaContext) +} + +func (s *Use_commandContext) Use_secondary_roles() IUse_secondary_rolesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_secondary_rolesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_secondary_rolesContext) +} + +func (s *Use_commandContext) Use_warehouse() IUse_warehouseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_warehouseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_warehouseContext) +} + +func (s *Use_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUse_command(s) + } +} + +func (s *Use_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUse_command(s) + } +} + +func (s *Use_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUse_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Use_command() (localctx IUse_commandContext) { + localctx = NewUse_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 634, SnowflakeParserRULE_use_command) + p.SetState(9518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1205, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9513) + p.Use_database() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9514) + p.Use_role() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9515) + p.Use_schema() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9516) + p.Use_secondary_roles() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9517) + p.Use_warehouse() + } + + 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 +} + +// IUse_databaseContext is an interface to support dynamic dispatch. +type IUse_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + + // IsUse_databaseContext differentiates from other interfaces. + IsUse_databaseContext() +} + +type Use_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUse_databaseContext() *Use_databaseContext { + var p = new(Use_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_database + return p +} + +func InitEmptyUse_databaseContext(p *Use_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_database +} + +func (*Use_databaseContext) IsUse_databaseContext() {} + +func NewUse_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_databaseContext { + var p = new(Use_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_use_database + + return p +} + +func (s *Use_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_databaseContext) USE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE, 0) +} + +func (s *Use_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Use_databaseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Use_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUse_database(s) + } +} + +func (s *Use_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUse_database(s) + } +} + +func (s *Use_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUse_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Use_database() (localctx IUse_databaseContext) { + localctx = NewUse_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 636, SnowflakeParserRULE_use_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9520) + p.Match(SnowflakeParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9521) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9522) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUse_roleContext is an interface to support dynamic dispatch. +type IUse_roleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USE() antlr.TerminalNode + ROLE() antlr.TerminalNode + Id_() IId_Context + + // IsUse_roleContext differentiates from other interfaces. + IsUse_roleContext() +} + +type Use_roleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUse_roleContext() *Use_roleContext { + var p = new(Use_roleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_role + return p +} + +func InitEmptyUse_roleContext(p *Use_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_role +} + +func (*Use_roleContext) IsUse_roleContext() {} + +func NewUse_roleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_roleContext { + var p = new(Use_roleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_use_role + + return p +} + +func (s *Use_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_roleContext) USE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE, 0) +} + +func (s *Use_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Use_roleContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Use_roleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_roleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_roleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUse_role(s) + } +} + +func (s *Use_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUse_role(s) + } +} + +func (s *Use_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUse_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Use_role() (localctx IUse_roleContext) { + localctx = NewUse_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 638, SnowflakeParserRULE_use_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9524) + p.Match(SnowflakeParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9525) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9526) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUse_schemaContext is an interface to support dynamic dispatch. +type IUse_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USE() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + SCHEMA() antlr.TerminalNode + DOT() antlr.TerminalNode + + // IsUse_schemaContext differentiates from other interfaces. + IsUse_schemaContext() +} + +type Use_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUse_schemaContext() *Use_schemaContext { + var p = new(Use_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_schema + return p +} + +func InitEmptyUse_schemaContext(p *Use_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_schema +} + +func (*Use_schemaContext) IsUse_schemaContext() {} + +func NewUse_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_schemaContext { + var p = new(Use_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_use_schema + + return p +} + +func (s *Use_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_schemaContext) USE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE, 0) +} + +func (s *Use_schemaContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Use_schemaContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Use_schemaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Use_schemaContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *Use_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUse_schema(s) + } +} + +func (s *Use_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUse_schema(s) + } +} + +func (s *Use_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUse_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Use_schema() (localctx IUse_schemaContext) { + localctx = NewUse_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 640, SnowflakeParserRULE_use_schema) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9528) + p.Match(SnowflakeParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSCHEMA { + { + p.SetState(9529) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9535) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1207, p.GetParserRuleContext()) == 1 { + { + p.SetState(9532) + p.Id_() + } + { + p.SetState(9533) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9537) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUse_secondary_rolesContext is an interface to support dynamic dispatch. +type IUse_secondary_rolesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USE() antlr.TerminalNode + SECONDARY() antlr.TerminalNode + ROLES() antlr.TerminalNode + ALL() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsUse_secondary_rolesContext differentiates from other interfaces. + IsUse_secondary_rolesContext() +} + +type Use_secondary_rolesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUse_secondary_rolesContext() *Use_secondary_rolesContext { + var p = new(Use_secondary_rolesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_secondary_roles + return p +} + +func InitEmptyUse_secondary_rolesContext(p *Use_secondary_rolesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_secondary_roles +} + +func (*Use_secondary_rolesContext) IsUse_secondary_rolesContext() {} + +func NewUse_secondary_rolesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_secondary_rolesContext { + var p = new(Use_secondary_rolesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_use_secondary_roles + + return p +} + +func (s *Use_secondary_rolesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_secondary_rolesContext) USE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE, 0) +} + +func (s *Use_secondary_rolesContext) SECONDARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECONDARY, 0) +} + +func (s *Use_secondary_rolesContext) ROLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLES, 0) +} + +func (s *Use_secondary_rolesContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Use_secondary_rolesContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *Use_secondary_rolesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_secondary_rolesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_secondary_rolesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUse_secondary_roles(s) + } +} + +func (s *Use_secondary_rolesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUse_secondary_roles(s) + } +} + +func (s *Use_secondary_rolesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUse_secondary_roles(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Use_secondary_roles() (localctx IUse_secondary_rolesContext) { + localctx = NewUse_secondary_rolesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 642, SnowflakeParserRULE_use_secondary_roles) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9539) + p.Match(SnowflakeParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9540) + p.Match(SnowflakeParserSECONDARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9541) + p.Match(SnowflakeParserROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9542) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserALL || _la == SnowflakeParserNONE) { + 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 +} + +// IUse_warehouseContext is an interface to support dynamic dispatch. +type IUse_warehouseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USE() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + Id_() IId_Context + + // IsUse_warehouseContext differentiates from other interfaces. + IsUse_warehouseContext() +} + +type Use_warehouseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUse_warehouseContext() *Use_warehouseContext { + var p = new(Use_warehouseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_warehouse + return p +} + +func InitEmptyUse_warehouseContext(p *Use_warehouseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_use_warehouse +} + +func (*Use_warehouseContext) IsUse_warehouseContext() {} + +func NewUse_warehouseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_warehouseContext { + var p = new(Use_warehouseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_use_warehouse + + return p +} + +func (s *Use_warehouseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_warehouseContext) USE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE, 0) +} + +func (s *Use_warehouseContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Use_warehouseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Use_warehouseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_warehouseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_warehouseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterUse_warehouse(s) + } +} + +func (s *Use_warehouseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitUse_warehouse(s) + } +} + +func (s *Use_warehouseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitUse_warehouse(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Use_warehouse() (localctx IUse_warehouseContext) { + localctx = NewUse_warehouseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 644, SnowflakeParserRULE_use_warehouse) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9544) + p.Match(SnowflakeParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9545) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9546) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_clauseContext is an interface to support dynamic dispatch. +type IComment_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsComment_clauseContext differentiates from other interfaces. + IsComment_clauseContext() +} + +type Comment_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComment_clauseContext() *Comment_clauseContext { + var p = new(Comment_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_comment_clause + return p +} + +func InitEmptyComment_clauseContext(p *Comment_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_comment_clause +} + +func (*Comment_clauseContext) IsComment_clauseContext() {} + +func NewComment_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_clauseContext { + var p = new(Comment_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_comment_clause + + return p +} + +func (s *Comment_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comment_clauseContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Comment_clauseContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Comment_clauseContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Comment_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comment_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comment_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterComment_clause(s) + } +} + +func (s *Comment_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitComment_clause(s) + } +} + +func (s *Comment_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitComment_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Comment_clause() (localctx IComment_clauseContext) { + localctx = NewComment_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 646, SnowflakeParserRULE_comment_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9548) + p.Match(SnowflakeParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9549) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9550) + p.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 +} + +// IIf_suspendedContext is an interface to support dynamic dispatch. +type IIf_suspendedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF() antlr.TerminalNode + SUSPENDED() antlr.TerminalNode + + // IsIf_suspendedContext differentiates from other interfaces. + IsIf_suspendedContext() +} + +type If_suspendedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIf_suspendedContext() *If_suspendedContext { + var p = new(If_suspendedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_if_suspended + return p +} + +func InitEmptyIf_suspendedContext(p *If_suspendedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_if_suspended +} + +func (*If_suspendedContext) IsIf_suspendedContext() {} + +func NewIf_suspendedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_suspendedContext { + var p = new(If_suspendedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_if_suspended + + return p +} + +func (s *If_suspendedContext) GetParser() antlr.Parser { return s.parser } + +func (s *If_suspendedContext) IF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIF, 0) +} + +func (s *If_suspendedContext) SUSPENDED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPENDED, 0) +} + +func (s *If_suspendedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *If_suspendedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *If_suspendedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIf_suspended(s) + } +} + +func (s *If_suspendedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIf_suspended(s) + } +} + +func (s *If_suspendedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIf_suspended(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) If_suspended() (localctx IIf_suspendedContext) { + localctx = NewIf_suspendedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 648, SnowflakeParserRULE_if_suspended) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9552) + p.Match(SnowflakeParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9553) + p.Match(SnowflakeParserSUSPENDED) + 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 +} + +// IIf_existsContext is an interface to support dynamic dispatch. +type IIf_existsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsIf_existsContext differentiates from other interfaces. + IsIf_existsContext() +} + +type If_existsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIf_existsContext() *If_existsContext { + var p = new(If_existsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_if_exists + return p +} + +func InitEmptyIf_existsContext(p *If_existsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_if_exists +} + +func (*If_existsContext) IsIf_existsContext() {} + +func NewIf_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_existsContext { + var p = new(If_existsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_if_exists + + return p +} + +func (s *If_existsContext) GetParser() antlr.Parser { return s.parser } + +func (s *If_existsContext) IF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIF, 0) +} + +func (s *If_existsContext) EXISTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXISTS, 0) +} + +func (s *If_existsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *If_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *If_existsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIf_exists(s) + } +} + +func (s *If_existsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIf_exists(s) + } +} + +func (s *If_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIf_exists(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) If_exists() (localctx IIf_existsContext) { + localctx = NewIf_existsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 650, SnowflakeParserRULE_if_exists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9555) + p.Match(SnowflakeParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9556) + p.Match(SnowflakeParserEXISTS) + 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 +} + +// IIf_not_existsContext is an interface to support dynamic dispatch. +type IIf_not_existsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IF() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + + // IsIf_not_existsContext differentiates from other interfaces. + IsIf_not_existsContext() +} + +type If_not_existsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIf_not_existsContext() *If_not_existsContext { + var p = new(If_not_existsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_if_not_exists + return p +} + +func InitEmptyIf_not_existsContext(p *If_not_existsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_if_not_exists +} + +func (*If_not_existsContext) IsIf_not_existsContext() {} + +func NewIf_not_existsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_not_existsContext { + var p = new(If_not_existsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_if_not_exists + + return p +} + +func (s *If_not_existsContext) GetParser() antlr.Parser { return s.parser } + +func (s *If_not_existsContext) IF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIF, 0) +} + +func (s *If_not_existsContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *If_not_existsContext) EXISTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXISTS, 0) +} + +func (s *If_not_existsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *If_not_existsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *If_not_existsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIf_not_exists(s) + } +} + +func (s *If_not_existsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIf_not_exists(s) + } +} + +func (s *If_not_existsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIf_not_exists(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) If_not_exists() (localctx IIf_not_existsContext) { + localctx = NewIf_not_existsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 652, SnowflakeParserRULE_if_not_exists) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9558) + p.Match(SnowflakeParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9559) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9560) + p.Match(SnowflakeParserEXISTS) + 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 +} + +// IOr_replaceContext is an interface to support dynamic dispatch. +type IOr_replaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsOr_replaceContext differentiates from other interfaces. + IsOr_replaceContext() +} + +type Or_replaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOr_replaceContext() *Or_replaceContext { + var p = new(Or_replaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_or_replace + return p +} + +func InitEmptyOr_replaceContext(p *Or_replaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_or_replace +} + +func (*Or_replaceContext) IsOr_replaceContext() {} + +func NewOr_replaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Or_replaceContext { + var p = new(Or_replaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_or_replace + + return p +} + +func (s *Or_replaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Or_replaceContext) OR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOR, 0) +} + +func (s *Or_replaceContext) REPLACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLACE, 0) +} + +func (s *Or_replaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Or_replaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Or_replaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterOr_replace(s) + } +} + +func (s *Or_replaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitOr_replace(s) + } +} + +func (s *Or_replaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitOr_replace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Or_replace() (localctx IOr_replaceContext) { + localctx = NewOr_replaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 654, SnowflakeParserRULE_or_replace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9562) + p.Match(SnowflakeParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9563) + p.Match(SnowflakeParserREPLACE) + 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 +} + +// IDescribeContext is an interface to support dynamic dispatch. +type IDescribeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DESC() antlr.TerminalNode + DESCRIBE() antlr.TerminalNode + + // IsDescribeContext differentiates from other interfaces. + IsDescribeContext() +} + +type DescribeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribeContext() *DescribeContext { + var p = new(DescribeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe + return p +} + +func InitEmptyDescribeContext(p *DescribeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe +} + +func (*DescribeContext) IsDescribeContext() {} + +func NewDescribeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DescribeContext { + var p = new(DescribeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe + + return p +} + +func (s *DescribeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DescribeContext) DESC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDESC, 0) +} + +func (s *DescribeContext) DESCRIBE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDESCRIBE, 0) +} + +func (s *DescribeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DescribeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DescribeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe(s) + } +} + +func (s *DescribeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe(s) + } +} + +func (s *DescribeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe() (localctx IDescribeContext) { + localctx = NewDescribeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 656, SnowflakeParserRULE_describe) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9565) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDESC || _la == SnowflakeParserDESCRIBE) { + 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 +} + +// IDescribe_commandContext is an interface to support dynamic dispatch. +type IDescribe_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe_alert() IDescribe_alertContext + Describe_database() IDescribe_databaseContext + Describe_dynamic_table() IDescribe_dynamic_tableContext + Describe_external_table() IDescribe_external_tableContext + Describe_file_format() IDescribe_file_formatContext + Describe_function() IDescribe_functionContext + Describe_integration() IDescribe_integrationContext + Describe_masking_policy() IDescribe_masking_policyContext + Describe_materialized_view() IDescribe_materialized_viewContext + Describe_network_policy() IDescribe_network_policyContext + Describe_pipe() IDescribe_pipeContext + Describe_procedure() IDescribe_procedureContext + Describe_result() IDescribe_resultContext + Describe_row_access_policy() IDescribe_row_access_policyContext + Describe_schema() IDescribe_schemaContext + Describe_search_optimization() IDescribe_search_optimizationContext + Describe_sequence() IDescribe_sequenceContext + Describe_session_policy() IDescribe_session_policyContext + Describe_share() IDescribe_shareContext + Describe_stage() IDescribe_stageContext + Describe_stream() IDescribe_streamContext + Describe_table() IDescribe_tableContext + Describe_task() IDescribe_taskContext + Describe_transaction() IDescribe_transactionContext + Describe_user() IDescribe_userContext + Describe_view() IDescribe_viewContext + Describe_warehouse() IDescribe_warehouseContext + + // IsDescribe_commandContext differentiates from other interfaces. + IsDescribe_commandContext() +} + +type Describe_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_commandContext() *Describe_commandContext { + var p = new(Describe_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_command + return p +} + +func InitEmptyDescribe_commandContext(p *Describe_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_command +} + +func (*Describe_commandContext) IsDescribe_commandContext() {} + +func NewDescribe_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_commandContext { + var p = new(Describe_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_command + + return p +} + +func (s *Describe_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_commandContext) Describe_alert() IDescribe_alertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_alertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_alertContext) +} + +func (s *Describe_commandContext) Describe_database() IDescribe_databaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_databaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_databaseContext) +} + +func (s *Describe_commandContext) Describe_dynamic_table() IDescribe_dynamic_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_dynamic_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_dynamic_tableContext) +} + +func (s *Describe_commandContext) Describe_external_table() IDescribe_external_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_external_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_external_tableContext) +} + +func (s *Describe_commandContext) Describe_file_format() IDescribe_file_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_file_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_file_formatContext) +} + +func (s *Describe_commandContext) Describe_function() IDescribe_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_functionContext) +} + +func (s *Describe_commandContext) Describe_integration() IDescribe_integrationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_integrationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_integrationContext) +} + +func (s *Describe_commandContext) Describe_masking_policy() IDescribe_masking_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_masking_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_masking_policyContext) +} + +func (s *Describe_commandContext) Describe_materialized_view() IDescribe_materialized_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_materialized_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_materialized_viewContext) +} + +func (s *Describe_commandContext) Describe_network_policy() IDescribe_network_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_network_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_network_policyContext) +} + +func (s *Describe_commandContext) Describe_pipe() IDescribe_pipeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_pipeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_pipeContext) +} + +func (s *Describe_commandContext) Describe_procedure() IDescribe_procedureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_procedureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_procedureContext) +} + +func (s *Describe_commandContext) Describe_result() IDescribe_resultContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_resultContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_resultContext) +} + +func (s *Describe_commandContext) Describe_row_access_policy() IDescribe_row_access_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_row_access_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_row_access_policyContext) +} + +func (s *Describe_commandContext) Describe_schema() IDescribe_schemaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_schemaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_schemaContext) +} + +func (s *Describe_commandContext) Describe_search_optimization() IDescribe_search_optimizationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_search_optimizationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_search_optimizationContext) +} + +func (s *Describe_commandContext) Describe_sequence() IDescribe_sequenceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_sequenceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_sequenceContext) +} + +func (s *Describe_commandContext) Describe_session_policy() IDescribe_session_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_session_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_session_policyContext) +} + +func (s *Describe_commandContext) Describe_share() IDescribe_shareContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_shareContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_shareContext) +} + +func (s *Describe_commandContext) Describe_stage() IDescribe_stageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_stageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_stageContext) +} + +func (s *Describe_commandContext) Describe_stream() IDescribe_streamContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_streamContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_streamContext) +} + +func (s *Describe_commandContext) Describe_table() IDescribe_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_tableContext) +} + +func (s *Describe_commandContext) Describe_task() IDescribe_taskContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_taskContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_taskContext) +} + +func (s *Describe_commandContext) Describe_transaction() IDescribe_transactionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_transactionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_transactionContext) +} + +func (s *Describe_commandContext) Describe_user() IDescribe_userContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_userContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_userContext) +} + +func (s *Describe_commandContext) Describe_view() IDescribe_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_viewContext) +} + +func (s *Describe_commandContext) Describe_warehouse() IDescribe_warehouseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribe_warehouseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribe_warehouseContext) +} + +func (s *Describe_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_command(s) + } +} + +func (s *Describe_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_command(s) + } +} + +func (s *Describe_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_command() (localctx IDescribe_commandContext) { + localctx = NewDescribe_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 658, SnowflakeParserRULE_describe_command) + p.SetState(9594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1208, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9567) + p.Describe_alert() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9568) + p.Describe_database() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9569) + p.Describe_dynamic_table() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9570) + p.Describe_external_table() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9571) + p.Describe_file_format() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9572) + p.Describe_function() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9573) + p.Describe_integration() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9574) + p.Describe_masking_policy() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9575) + p.Describe_materialized_view() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9576) + p.Describe_network_policy() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9577) + p.Describe_pipe() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9578) + p.Describe_procedure() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(9579) + p.Describe_result() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(9580) + p.Describe_row_access_policy() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(9581) + p.Describe_schema() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(9582) + p.Describe_search_optimization() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(9583) + p.Describe_sequence() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(9584) + p.Describe_session_policy() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(9585) + p.Describe_share() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(9586) + p.Describe_stage() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(9587) + p.Describe_stream() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(9588) + p.Describe_table() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(9589) + p.Describe_task() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(9590) + p.Describe_transaction() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(9591) + p.Describe_user() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(9592) + p.Describe_view() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(9593) + p.Describe_warehouse() + } + + 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 +} + +// IDescribe_alertContext is an interface to support dynamic dispatch. +type IDescribe_alertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + ALERT() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_alertContext differentiates from other interfaces. + IsDescribe_alertContext() +} + +type Describe_alertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_alertContext() *Describe_alertContext { + var p = new(Describe_alertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_alert + return p +} + +func InitEmptyDescribe_alertContext(p *Describe_alertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_alert +} + +func (*Describe_alertContext) IsDescribe_alertContext() {} + +func NewDescribe_alertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_alertContext { + var p = new(Describe_alertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_alert + + return p +} + +func (s *Describe_alertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_alertContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_alertContext) ALERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERT, 0) +} + +func (s *Describe_alertContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_alertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_alertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_alertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_alert(s) + } +} + +func (s *Describe_alertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_alert(s) + } +} + +func (s *Describe_alertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_alert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_alert() (localctx IDescribe_alertContext) { + localctx = NewDescribe_alertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 660, SnowflakeParserRULE_describe_alert) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9596) + p.Describe() + } + { + p.SetState(9597) + p.Match(SnowflakeParserALERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9598) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_databaseContext is an interface to support dynamic dispatch. +type IDescribe_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + DATABASE() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_databaseContext differentiates from other interfaces. + IsDescribe_databaseContext() +} + +type Describe_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_databaseContext() *Describe_databaseContext { + var p = new(Describe_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_database + return p +} + +func InitEmptyDescribe_databaseContext(p *Describe_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_database +} + +func (*Describe_databaseContext) IsDescribe_databaseContext() {} + +func NewDescribe_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_databaseContext { + var p = new(Describe_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_database + + return p +} + +func (s *Describe_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_databaseContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Describe_databaseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_database(s) + } +} + +func (s *Describe_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_database(s) + } +} + +func (s *Describe_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_database() (localctx IDescribe_databaseContext) { + localctx = NewDescribe_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 662, SnowflakeParserRULE_describe_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9600) + p.Describe() + } + { + p.SetState(9601) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9602) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_dynamic_tableContext is an interface to support dynamic dispatch. +type IDescribe_dynamic_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + DYNAMIC() antlr.TerminalNode + TABLE() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_dynamic_tableContext differentiates from other interfaces. + IsDescribe_dynamic_tableContext() +} + +type Describe_dynamic_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_dynamic_tableContext() *Describe_dynamic_tableContext { + var p = new(Describe_dynamic_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_dynamic_table + return p +} + +func InitEmptyDescribe_dynamic_tableContext(p *Describe_dynamic_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_dynamic_table +} + +func (*Describe_dynamic_tableContext) IsDescribe_dynamic_tableContext() {} + +func NewDescribe_dynamic_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_dynamic_tableContext { + var p = new(Describe_dynamic_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_dynamic_table + + return p +} + +func (s *Describe_dynamic_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_dynamic_tableContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_dynamic_tableContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDYNAMIC, 0) +} + +func (s *Describe_dynamic_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Describe_dynamic_tableContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_dynamic_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_dynamic_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_dynamic_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_dynamic_table(s) + } +} + +func (s *Describe_dynamic_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_dynamic_table(s) + } +} + +func (s *Describe_dynamic_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_dynamic_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_dynamic_table() (localctx IDescribe_dynamic_tableContext) { + localctx = NewDescribe_dynamic_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 664, SnowflakeParserRULE_describe_dynamic_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9604) + p.Describe() + } + { + p.SetState(9605) + p.Match(SnowflakeParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9606) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9607) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_external_tableContext is an interface to support dynamic dispatch. +type IDescribe_external_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + EXTERNAL() antlr.TerminalNode + TYPE() antlr.TerminalNode + EQ() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + STAGE() antlr.TerminalNode + + // IsDescribe_external_tableContext differentiates from other interfaces. + IsDescribe_external_tableContext() +} + +type Describe_external_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_external_tableContext() *Describe_external_tableContext { + var p = new(Describe_external_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_external_table + return p +} + +func InitEmptyDescribe_external_tableContext(p *Describe_external_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_external_table +} + +func (*Describe_external_tableContext) IsDescribe_external_tableContext() {} + +func NewDescribe_external_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_external_tableContext { + var p = new(Describe_external_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_external_table + + return p +} + +func (s *Describe_external_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_external_tableContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_external_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Describe_external_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_external_tableContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Describe_external_tableContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Describe_external_tableContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Describe_external_tableContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMNS, 0) +} + +func (s *Describe_external_tableContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Describe_external_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_external_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_external_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_external_table(s) + } +} + +func (s *Describe_external_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_external_table(s) + } +} + +func (s *Describe_external_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_external_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_external_table() (localctx IDescribe_external_tableContext) { + localctx = NewDescribe_external_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 666, SnowflakeParserRULE_describe_external_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9609) + p.Describe() + } + p.SetState(9611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserEXTERNAL { + { + p.SetState(9610) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9613) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9614) + p.Object_name() + } + p.SetState(9618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(9615) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9616) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9617) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOLUMNS || _la == SnowflakeParserSTAGE) { + 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 +} + +// IDescribe_file_formatContext is an interface to support dynamic dispatch. +type IDescribe_file_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + FILE() antlr.TerminalNode + FORMAT() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_file_formatContext differentiates from other interfaces. + IsDescribe_file_formatContext() +} + +type Describe_file_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_file_formatContext() *Describe_file_formatContext { + var p = new(Describe_file_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_file_format + return p +} + +func InitEmptyDescribe_file_formatContext(p *Describe_file_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_file_format +} + +func (*Describe_file_formatContext) IsDescribe_file_formatContext() {} + +func NewDescribe_file_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_file_formatContext { + var p = new(Describe_file_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_file_format + + return p +} + +func (s *Describe_file_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_file_formatContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_file_formatContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Describe_file_formatContext) FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT, 0) +} + +func (s *Describe_file_formatContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_file_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_file_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_file_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_file_format(s) + } +} + +func (s *Describe_file_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_file_format(s) + } +} + +func (s *Describe_file_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_file_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_file_format() (localctx IDescribe_file_formatContext) { + localctx = NewDescribe_file_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 668, SnowflakeParserRULE_describe_file_format) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9620) + p.Describe() + } + { + p.SetState(9621) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9622) + p.Match(SnowflakeParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9623) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_functionContext is an interface to support dynamic dispatch. +type IDescribe_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + FUNCTION() antlr.TerminalNode + Object_name() IObject_nameContext + Arg_types() IArg_typesContext + + // IsDescribe_functionContext differentiates from other interfaces. + IsDescribe_functionContext() +} + +type Describe_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_functionContext() *Describe_functionContext { + var p = new(Describe_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_function + return p +} + +func InitEmptyDescribe_functionContext(p *Describe_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_function +} + +func (*Describe_functionContext) IsDescribe_functionContext() {} + +func NewDescribe_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_functionContext { + var p = new(Describe_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_function + + return p +} + +func (s *Describe_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_functionContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Describe_functionContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_functionContext) Arg_types() IArg_typesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_typesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArg_typesContext) +} + +func (s *Describe_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_function(s) + } +} + +func (s *Describe_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_function(s) + } +} + +func (s *Describe_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_function() (localctx IDescribe_functionContext) { + localctx = NewDescribe_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 670, SnowflakeParserRULE_describe_function) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9625) + p.Describe() + } + { + p.SetState(9626) + p.Match(SnowflakeParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9627) + p.Object_name() + } + { + p.SetState(9628) + p.Arg_types() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_integrationContext is an interface to support dynamic dispatch. +type IDescribe_integrationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + INTEGRATION() antlr.TerminalNode + Id_() IId_Context + API() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + SECURITY() antlr.TerminalNode + STORAGE() antlr.TerminalNode + + // IsDescribe_integrationContext differentiates from other interfaces. + IsDescribe_integrationContext() +} + +type Describe_integrationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_integrationContext() *Describe_integrationContext { + var p = new(Describe_integrationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_integration + return p +} + +func InitEmptyDescribe_integrationContext(p *Describe_integrationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_integration +} + +func (*Describe_integrationContext) IsDescribe_integrationContext() {} + +func NewDescribe_integrationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_integrationContext { + var p = new(Describe_integrationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_integration + + return p +} + +func (s *Describe_integrationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_integrationContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_integrationContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Describe_integrationContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_integrationContext) API() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI, 0) +} + +func (s *Describe_integrationContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION, 0) +} + +func (s *Describe_integrationContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Describe_integrationContext) STORAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE, 0) +} + +func (s *Describe_integrationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_integrationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_integrationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_integration(s) + } +} + +func (s *Describe_integrationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_integration(s) + } +} + +func (s *Describe_integrationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_integration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_integration() (localctx IDescribe_integrationContext) { + localctx = NewDescribe_integrationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 672, SnowflakeParserRULE_describe_integration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9630) + p.Describe() + } + p.SetState(9632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI || _la == SnowflakeParserNOTIFICATION || _la == SnowflakeParserSECURITY || _la == SnowflakeParserSTORAGE { + { + p.SetState(9631) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAPI || _la == SnowflakeParserNOTIFICATION || _la == SnowflakeParserSECURITY || _la == SnowflakeParserSTORAGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(9634) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9635) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_masking_policyContext is an interface to support dynamic dispatch. +type IDescribe_masking_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + MASKING() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_masking_policyContext differentiates from other interfaces. + IsDescribe_masking_policyContext() +} + +type Describe_masking_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_masking_policyContext() *Describe_masking_policyContext { + var p = new(Describe_masking_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_masking_policy + return p +} + +func InitEmptyDescribe_masking_policyContext(p *Describe_masking_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_masking_policy +} + +func (*Describe_masking_policyContext) IsDescribe_masking_policyContext() {} + +func NewDescribe_masking_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_masking_policyContext { + var p = new(Describe_masking_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_masking_policy + + return p +} + +func (s *Describe_masking_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_masking_policyContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_masking_policyContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Describe_masking_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Describe_masking_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_masking_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_masking_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_masking_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_masking_policy(s) + } +} + +func (s *Describe_masking_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_masking_policy(s) + } +} + +func (s *Describe_masking_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_masking_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_masking_policy() (localctx IDescribe_masking_policyContext) { + localctx = NewDescribe_masking_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 674, SnowflakeParserRULE_describe_masking_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9637) + p.Describe() + } + { + p.SetState(9638) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9639) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9640) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_materialized_viewContext is an interface to support dynamic dispatch. +type IDescribe_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsDescribe_materialized_viewContext differentiates from other interfaces. + IsDescribe_materialized_viewContext() +} + +type Describe_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_materialized_viewContext() *Describe_materialized_viewContext { + var p = new(Describe_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_materialized_view + return p +} + +func InitEmptyDescribe_materialized_viewContext(p *Describe_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_materialized_view +} + +func (*Describe_materialized_viewContext) IsDescribe_materialized_viewContext() {} + +func NewDescribe_materialized_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_materialized_viewContext { + var p = new(Describe_materialized_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_materialized_view + + return p +} + +func (s *Describe_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_materialized_viewContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATERIALIZED, 0) +} + +func (s *Describe_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Describe_materialized_viewContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_materialized_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_materialized_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_materialized_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_materialized_view(s) + } +} + +func (s *Describe_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_materialized_view(s) + } +} + +func (s *Describe_materialized_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_materialized_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_materialized_view() (localctx IDescribe_materialized_viewContext) { + localctx = NewDescribe_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 676, SnowflakeParserRULE_describe_materialized_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9642) + p.Describe() + } + { + p.SetState(9643) + p.Match(SnowflakeParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9644) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9645) + p.Object_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 +} + +// IDescribe_network_policyContext is an interface to support dynamic dispatch. +type IDescribe_network_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + NETWORK() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_network_policyContext differentiates from other interfaces. + IsDescribe_network_policyContext() +} + +type Describe_network_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_network_policyContext() *Describe_network_policyContext { + var p = new(Describe_network_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_network_policy + return p +} + +func InitEmptyDescribe_network_policyContext(p *Describe_network_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_network_policy +} + +func (*Describe_network_policyContext) IsDescribe_network_policyContext() {} + +func NewDescribe_network_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_network_policyContext { + var p = new(Describe_network_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_network_policy + + return p +} + +func (s *Describe_network_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_network_policyContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_network_policyContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Describe_network_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Describe_network_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_network_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_network_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_network_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_network_policy(s) + } +} + +func (s *Describe_network_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_network_policy(s) + } +} + +func (s *Describe_network_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_network_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_network_policy() (localctx IDescribe_network_policyContext) { + localctx = NewDescribe_network_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 678, SnowflakeParserRULE_describe_network_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9647) + p.Describe() + } + { + p.SetState(9648) + p.Match(SnowflakeParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9649) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9650) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_pipeContext is an interface to support dynamic dispatch. +type IDescribe_pipeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + PIPE() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsDescribe_pipeContext differentiates from other interfaces. + IsDescribe_pipeContext() +} + +type Describe_pipeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_pipeContext() *Describe_pipeContext { + var p = new(Describe_pipeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_pipe + return p +} + +func InitEmptyDescribe_pipeContext(p *Describe_pipeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_pipe +} + +func (*Describe_pipeContext) IsDescribe_pipeContext() {} + +func NewDescribe_pipeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_pipeContext { + var p = new(Describe_pipeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_pipe + + return p +} + +func (s *Describe_pipeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_pipeContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_pipeContext) PIPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE, 0) +} + +func (s *Describe_pipeContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_pipeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_pipeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_pipeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_pipe(s) + } +} + +func (s *Describe_pipeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_pipe(s) + } +} + +func (s *Describe_pipeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_pipe(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_pipe() (localctx IDescribe_pipeContext) { + localctx = NewDescribe_pipeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 680, SnowflakeParserRULE_describe_pipe) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9652) + p.Describe() + } + { + p.SetState(9653) + p.Match(SnowflakeParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9654) + p.Object_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 +} + +// IDescribe_procedureContext is an interface to support dynamic dispatch. +type IDescribe_procedureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + PROCEDURE() antlr.TerminalNode + Object_name() IObject_nameContext + Arg_types() IArg_typesContext + + // IsDescribe_procedureContext differentiates from other interfaces. + IsDescribe_procedureContext() +} + +type Describe_procedureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_procedureContext() *Describe_procedureContext { + var p = new(Describe_procedureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_procedure + return p +} + +func InitEmptyDescribe_procedureContext(p *Describe_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_procedure +} + +func (*Describe_procedureContext) IsDescribe_procedureContext() {} + +func NewDescribe_procedureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_procedureContext { + var p = new(Describe_procedureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_procedure + + return p +} + +func (s *Describe_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_procedureContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE, 0) +} + +func (s *Describe_procedureContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_procedureContext) Arg_types() IArg_typesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArg_typesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArg_typesContext) +} + +func (s *Describe_procedureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_procedureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_procedureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_procedure(s) + } +} + +func (s *Describe_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_procedure(s) + } +} + +func (s *Describe_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_procedure() (localctx IDescribe_procedureContext) { + localctx = NewDescribe_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 682, SnowflakeParserRULE_describe_procedure) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9656) + p.Describe() + } + { + p.SetState(9657) + p.Match(SnowflakeParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9658) + p.Object_name() + } + { + p.SetState(9659) + p.Arg_types() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_resultContext is an interface to support dynamic dispatch. +type IDescribe_resultContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + RESULT() antlr.TerminalNode + STRING() antlr.TerminalNode + LAST_QUERY_ID() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsDescribe_resultContext differentiates from other interfaces. + IsDescribe_resultContext() +} + +type Describe_resultContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_resultContext() *Describe_resultContext { + var p = new(Describe_resultContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_result + return p +} + +func InitEmptyDescribe_resultContext(p *Describe_resultContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_result +} + +func (*Describe_resultContext) IsDescribe_resultContext() {} + +func NewDescribe_resultContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_resultContext { + var p = new(Describe_resultContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_result + + return p +} + +func (s *Describe_resultContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_resultContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_resultContext) RESULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESULT, 0) +} + +func (s *Describe_resultContext) STRING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING, 0) +} + +func (s *Describe_resultContext) LAST_QUERY_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST_QUERY_ID, 0) +} + +func (s *Describe_resultContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Describe_resultContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Describe_resultContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_resultContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_resultContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_result(s) + } +} + +func (s *Describe_resultContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_result(s) + } +} + +func (s *Describe_resultContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_result(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_result() (localctx IDescribe_resultContext) { + localctx = NewDescribe_resultContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 684, SnowflakeParserRULE_describe_result) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9661) + p.Describe() + } + { + p.SetState(9662) + p.Match(SnowflakeParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSTRING: + { + p.SetState(9663) + p.Match(SnowflakeParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserLAST_QUERY_ID: + { + p.SetState(9664) + p.Match(SnowflakeParserLAST_QUERY_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9665) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9666) + p.Match(SnowflakeParserRR_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 +} + +// IDescribe_row_access_policyContext is an interface to support dynamic dispatch. +type IDescribe_row_access_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_row_access_policyContext differentiates from other interfaces. + IsDescribe_row_access_policyContext() +} + +type Describe_row_access_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_row_access_policyContext() *Describe_row_access_policyContext { + var p = new(Describe_row_access_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_row_access_policy + return p +} + +func InitEmptyDescribe_row_access_policyContext(p *Describe_row_access_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_row_access_policy +} + +func (*Describe_row_access_policyContext) IsDescribe_row_access_policyContext() {} + +func NewDescribe_row_access_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_row_access_policyContext { + var p = new(Describe_row_access_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_row_access_policy + + return p +} + +func (s *Describe_row_access_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_row_access_policyContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_row_access_policyContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Describe_row_access_policyContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Describe_row_access_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Describe_row_access_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_row_access_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_row_access_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_row_access_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_row_access_policy(s) + } +} + +func (s *Describe_row_access_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_row_access_policy(s) + } +} + +func (s *Describe_row_access_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_row_access_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_row_access_policy() (localctx IDescribe_row_access_policyContext) { + localctx = NewDescribe_row_access_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 686, SnowflakeParserRULE_describe_row_access_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9669) + p.Describe() + } + { + p.SetState(9670) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9671) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9672) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9673) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_schemaContext is an interface to support dynamic dispatch. +type IDescribe_schemaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsDescribe_schemaContext differentiates from other interfaces. + IsDescribe_schemaContext() +} + +type Describe_schemaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_schemaContext() *Describe_schemaContext { + var p = new(Describe_schemaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_schema + return p +} + +func InitEmptyDescribe_schemaContext(p *Describe_schemaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_schema +} + +func (*Describe_schemaContext) IsDescribe_schemaContext() {} + +func NewDescribe_schemaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_schemaContext { + var p = new(Describe_schemaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_schema + + return p +} + +func (s *Describe_schemaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_schemaContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_schemaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Describe_schemaContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Describe_schemaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_schemaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_schemaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_schema(s) + } +} + +func (s *Describe_schemaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_schema(s) + } +} + +func (s *Describe_schemaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_schema(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_schema() (localctx IDescribe_schemaContext) { + localctx = NewDescribe_schemaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 688, SnowflakeParserRULE_describe_schema) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9675) + p.Describe() + } + { + p.SetState(9676) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9677) + p.Schema_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 +} + +// IDescribe_search_optimizationContext is an interface to support dynamic dispatch. +type IDescribe_search_optimizationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + SEARCH() antlr.TerminalNode + OPTIMIZATION() antlr.TerminalNode + ON() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsDescribe_search_optimizationContext differentiates from other interfaces. + IsDescribe_search_optimizationContext() +} + +type Describe_search_optimizationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_search_optimizationContext() *Describe_search_optimizationContext { + var p = new(Describe_search_optimizationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_search_optimization + return p +} + +func InitEmptyDescribe_search_optimizationContext(p *Describe_search_optimizationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_search_optimization +} + +func (*Describe_search_optimizationContext) IsDescribe_search_optimizationContext() {} + +func NewDescribe_search_optimizationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_search_optimizationContext { + var p = new(Describe_search_optimizationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_search_optimization + + return p +} + +func (s *Describe_search_optimizationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_search_optimizationContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_search_optimizationContext) SEARCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEARCH, 0) +} + +func (s *Describe_search_optimizationContext) OPTIMIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPTIMIZATION, 0) +} + +func (s *Describe_search_optimizationContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Describe_search_optimizationContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_search_optimizationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_search_optimizationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_search_optimizationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_search_optimization(s) + } +} + +func (s *Describe_search_optimizationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_search_optimization(s) + } +} + +func (s *Describe_search_optimizationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_search_optimization(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_search_optimization() (localctx IDescribe_search_optimizationContext) { + localctx = NewDescribe_search_optimizationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 690, SnowflakeParserRULE_describe_search_optimization) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9679) + p.Describe() + } + { + p.SetState(9680) + p.Match(SnowflakeParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9681) + p.Match(SnowflakeParserOPTIMIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9682) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9683) + p.Object_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 +} + +// IDescribe_sequenceContext is an interface to support dynamic dispatch. +type IDescribe_sequenceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + SEQUENCE() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsDescribe_sequenceContext differentiates from other interfaces. + IsDescribe_sequenceContext() +} + +type Describe_sequenceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_sequenceContext() *Describe_sequenceContext { + var p = new(Describe_sequenceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_sequence + return p +} + +func InitEmptyDescribe_sequenceContext(p *Describe_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_sequence +} + +func (*Describe_sequenceContext) IsDescribe_sequenceContext() {} + +func NewDescribe_sequenceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_sequenceContext { + var p = new(Describe_sequenceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_sequence + + return p +} + +func (s *Describe_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_sequenceContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 0) +} + +func (s *Describe_sequenceContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_sequenceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_sequenceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_sequenceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_sequence(s) + } +} + +func (s *Describe_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_sequence(s) + } +} + +func (s *Describe_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_sequence() (localctx IDescribe_sequenceContext) { + localctx = NewDescribe_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 692, SnowflakeParserRULE_describe_sequence) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9685) + p.Describe() + } + { + p.SetState(9686) + p.Match(SnowflakeParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9687) + p.Object_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 +} + +// IDescribe_session_policyContext is an interface to support dynamic dispatch. +type IDescribe_session_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + SESSION() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_session_policyContext differentiates from other interfaces. + IsDescribe_session_policyContext() +} + +type Describe_session_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_session_policyContext() *Describe_session_policyContext { + var p = new(Describe_session_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_session_policy + return p +} + +func InitEmptyDescribe_session_policyContext(p *Describe_session_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_session_policy +} + +func (*Describe_session_policyContext) IsDescribe_session_policyContext() {} + +func NewDescribe_session_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_session_policyContext { + var p = new(Describe_session_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_session_policy + + return p +} + +func (s *Describe_session_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_session_policyContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_session_policyContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Describe_session_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Describe_session_policyContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_session_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_session_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_session_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_session_policy(s) + } +} + +func (s *Describe_session_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_session_policy(s) + } +} + +func (s *Describe_session_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_session_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_session_policy() (localctx IDescribe_session_policyContext) { + localctx = NewDescribe_session_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 694, SnowflakeParserRULE_describe_session_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9689) + p.Describe() + } + { + p.SetState(9690) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9691) + p.Match(SnowflakeParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9692) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_shareContext is an interface to support dynamic dispatch. +type IDescribe_shareContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + SHARE() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_shareContext differentiates from other interfaces. + IsDescribe_shareContext() +} + +type Describe_shareContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_shareContext() *Describe_shareContext { + var p = new(Describe_shareContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_share + return p +} + +func InitEmptyDescribe_shareContext(p *Describe_shareContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_share +} + +func (*Describe_shareContext) IsDescribe_shareContext() {} + +func NewDescribe_shareContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_shareContext { + var p = new(Describe_shareContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_share + + return p +} + +func (s *Describe_shareContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_shareContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_shareContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Describe_shareContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_shareContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_shareContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_shareContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_share(s) + } +} + +func (s *Describe_shareContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_share(s) + } +} + +func (s *Describe_shareContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_share(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_share() (localctx IDescribe_shareContext) { + localctx = NewDescribe_shareContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 696, SnowflakeParserRULE_describe_share) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9694) + p.Describe() + } + { + p.SetState(9695) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9696) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_stageContext is an interface to support dynamic dispatch. +type IDescribe_stageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + STAGE() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsDescribe_stageContext differentiates from other interfaces. + IsDescribe_stageContext() +} + +type Describe_stageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_stageContext() *Describe_stageContext { + var p = new(Describe_stageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_stage + return p +} + +func InitEmptyDescribe_stageContext(p *Describe_stageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_stage +} + +func (*Describe_stageContext) IsDescribe_stageContext() {} + +func NewDescribe_stageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_stageContext { + var p = new(Describe_stageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_stage + + return p +} + +func (s *Describe_stageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_stageContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_stageContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Describe_stageContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_stageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_stageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_stageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_stage(s) + } +} + +func (s *Describe_stageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_stage(s) + } +} + +func (s *Describe_stageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_stage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_stage() (localctx IDescribe_stageContext) { + localctx = NewDescribe_stageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 698, SnowflakeParserRULE_describe_stage) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9698) + p.Describe() + } + { + p.SetState(9699) + p.Match(SnowflakeParserSTAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9700) + p.Object_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 +} + +// IDescribe_streamContext is an interface to support dynamic dispatch. +type IDescribe_streamContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + STREAM() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsDescribe_streamContext differentiates from other interfaces. + IsDescribe_streamContext() +} + +type Describe_streamContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_streamContext() *Describe_streamContext { + var p = new(Describe_streamContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_stream + return p +} + +func InitEmptyDescribe_streamContext(p *Describe_streamContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_stream +} + +func (*Describe_streamContext) IsDescribe_streamContext() {} + +func NewDescribe_streamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_streamContext { + var p = new(Describe_streamContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_stream + + return p +} + +func (s *Describe_streamContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_streamContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_streamContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Describe_streamContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_streamContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_streamContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_streamContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_stream(s) + } +} + +func (s *Describe_streamContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_stream(s) + } +} + +func (s *Describe_streamContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_stream(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_stream() (localctx IDescribe_streamContext) { + localctx = NewDescribe_streamContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 700, SnowflakeParserRULE_describe_stream) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9702) + p.Describe() + } + { + p.SetState(9703) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9704) + p.Object_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 +} + +// IDescribe_tableContext is an interface to support dynamic dispatch. +type IDescribe_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + TYPE() antlr.TerminalNode + EQ() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + STAGE() antlr.TerminalNode + + // IsDescribe_tableContext differentiates from other interfaces. + IsDescribe_tableContext() +} + +type Describe_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_tableContext() *Describe_tableContext { + var p = new(Describe_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_table + return p +} + +func InitEmptyDescribe_tableContext(p *Describe_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_table +} + +func (*Describe_tableContext) IsDescribe_tableContext() {} + +func NewDescribe_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_tableContext { + var p = new(Describe_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_table + + return p +} + +func (s *Describe_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_tableContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Describe_tableContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_tableContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Describe_tableContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Describe_tableContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMNS, 0) +} + +func (s *Describe_tableContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Describe_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_table(s) + } +} + +func (s *Describe_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_table(s) + } +} + +func (s *Describe_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_table() (localctx IDescribe_tableContext) { + localctx = NewDescribe_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 702, SnowflakeParserRULE_describe_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9706) + p.Describe() + } + { + p.SetState(9707) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9708) + p.Object_name() + } + p.SetState(9712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTYPE { + { + p.SetState(9709) + p.Match(SnowflakeParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9710) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9711) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserCOLUMNS || _la == SnowflakeParserSTAGE) { + 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 +} + +// IDescribe_taskContext is an interface to support dynamic dispatch. +type IDescribe_taskContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + TASK() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsDescribe_taskContext differentiates from other interfaces. + IsDescribe_taskContext() +} + +type Describe_taskContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_taskContext() *Describe_taskContext { + var p = new(Describe_taskContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_task + return p +} + +func InitEmptyDescribe_taskContext(p *Describe_taskContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_task +} + +func (*Describe_taskContext) IsDescribe_taskContext() {} + +func NewDescribe_taskContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_taskContext { + var p = new(Describe_taskContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_task + + return p +} + +func (s *Describe_taskContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_taskContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_taskContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Describe_taskContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_taskContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_taskContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_taskContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_task(s) + } +} + +func (s *Describe_taskContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_task(s) + } +} + +func (s *Describe_taskContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_task(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_task() (localctx IDescribe_taskContext) { + localctx = NewDescribe_taskContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 704, SnowflakeParserRULE_describe_task) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9714) + p.Describe() + } + { + p.SetState(9715) + p.Match(SnowflakeParserTASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9716) + p.Object_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 +} + +// IDescribe_transactionContext is an interface to support dynamic dispatch. +type IDescribe_transactionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + TRANSACTION() antlr.TerminalNode + Num() INumContext + + // IsDescribe_transactionContext differentiates from other interfaces. + IsDescribe_transactionContext() +} + +type Describe_transactionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_transactionContext() *Describe_transactionContext { + var p = new(Describe_transactionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_transaction + return p +} + +func InitEmptyDescribe_transactionContext(p *Describe_transactionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_transaction +} + +func (*Describe_transactionContext) IsDescribe_transactionContext() {} + +func NewDescribe_transactionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_transactionContext { + var p = new(Describe_transactionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_transaction + + return p +} + +func (s *Describe_transactionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_transactionContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_transactionContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTION, 0) +} + +func (s *Describe_transactionContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Describe_transactionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_transactionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_transactionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_transaction(s) + } +} + +func (s *Describe_transactionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_transaction(s) + } +} + +func (s *Describe_transactionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_transaction(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_transaction() (localctx IDescribe_transactionContext) { + localctx = NewDescribe_transactionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 706, SnowflakeParserRULE_describe_transaction) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9718) + p.Describe() + } + { + p.SetState(9719) + p.Match(SnowflakeParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9720) + p.Num() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_userContext is an interface to support dynamic dispatch. +type IDescribe_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + USER() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_userContext differentiates from other interfaces. + IsDescribe_userContext() +} + +type Describe_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_userContext() *Describe_userContext { + var p = new(Describe_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_user + return p +} + +func InitEmptyDescribe_userContext(p *Describe_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_user +} + +func (*Describe_userContext) IsDescribe_userContext() {} + +func NewDescribe_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_userContext { + var p = new(Describe_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_user + + return p +} + +func (s *Describe_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_userContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_userContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Describe_userContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_user(s) + } +} + +func (s *Describe_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_user(s) + } +} + +func (s *Describe_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_user() (localctx IDescribe_userContext) { + localctx = NewDescribe_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 708, SnowflakeParserRULE_describe_user) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9722) + p.Describe() + } + { + p.SetState(9723) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9724) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescribe_viewContext is an interface to support dynamic dispatch. +type IDescribe_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + VIEW() antlr.TerminalNode + Object_name() IObject_nameContext + + // IsDescribe_viewContext differentiates from other interfaces. + IsDescribe_viewContext() +} + +type Describe_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_viewContext() *Describe_viewContext { + var p = new(Describe_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_view + return p +} + +func InitEmptyDescribe_viewContext(p *Describe_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_view +} + +func (*Describe_viewContext) IsDescribe_viewContext() {} + +func NewDescribe_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_viewContext { + var p = new(Describe_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_view + + return p +} + +func (s *Describe_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_viewContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Describe_viewContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Describe_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_view(s) + } +} + +func (s *Describe_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_view(s) + } +} + +func (s *Describe_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_view() (localctx IDescribe_viewContext) { + localctx = NewDescribe_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 710, SnowflakeParserRULE_describe_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9726) + p.Describe() + } + { + p.SetState(9727) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9728) + p.Object_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 +} + +// IDescribe_warehouseContext is an interface to support dynamic dispatch. +type IDescribe_warehouseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Describe() IDescribeContext + WAREHOUSE() antlr.TerminalNode + Id_() IId_Context + + // IsDescribe_warehouseContext differentiates from other interfaces. + IsDescribe_warehouseContext() +} + +type Describe_warehouseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDescribe_warehouseContext() *Describe_warehouseContext { + var p = new(Describe_warehouseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_warehouse + return p +} + +func InitEmptyDescribe_warehouseContext(p *Describe_warehouseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_describe_warehouse +} + +func (*Describe_warehouseContext) IsDescribe_warehouseContext() {} + +func NewDescribe_warehouseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Describe_warehouseContext { + var p = new(Describe_warehouseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_describe_warehouse + + return p +} + +func (s *Describe_warehouseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Describe_warehouseContext) Describe() IDescribeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescribeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescribeContext) +} + +func (s *Describe_warehouseContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Describe_warehouseContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Describe_warehouseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Describe_warehouseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Describe_warehouseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDescribe_warehouse(s) + } +} + +func (s *Describe_warehouseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDescribe_warehouse(s) + } +} + +func (s *Describe_warehouseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDescribe_warehouse(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Describe_warehouse() (localctx IDescribe_warehouseContext) { + localctx = NewDescribe_warehouseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 712, SnowflakeParserRULE_describe_warehouse) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9730) + p.Describe() + } + { + p.SetState(9731) + p.Match(SnowflakeParserWAREHOUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9732) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_commandContext is an interface to support dynamic dispatch. +type IShow_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Show_alerts() IShow_alertsContext + Show_columns() IShow_columnsContext + Show_connections() IShow_connectionsContext + Show_databases() IShow_databasesContext + Show_databases_in_failover_group() IShow_databases_in_failover_groupContext + Show_databases_in_replication_group() IShow_databases_in_replication_groupContext + Show_delegated_authorizations() IShow_delegated_authorizationsContext + Show_external_functions() IShow_external_functionsContext + Show_dynamic_tables() IShow_dynamic_tablesContext + Show_external_tables() IShow_external_tablesContext + Show_failover_groups() IShow_failover_groupsContext + Show_file_formats() IShow_file_formatsContext + Show_functions() IShow_functionsContext + Show_global_accounts() IShow_global_accountsContext + Show_grants() IShow_grantsContext + Show_integrations() IShow_integrationsContext + Show_locks() IShow_locksContext + Show_managed_accounts() IShow_managed_accountsContext + Show_masking_policies() IShow_masking_policiesContext + Show_materialized_views() IShow_materialized_viewsContext + Show_network_policies() IShow_network_policiesContext + Show_objects() IShow_objectsContext + Show_organization_accounts() IShow_organization_accountsContext + Show_parameters() IShow_parametersContext + Show_pipes() IShow_pipesContext + Show_primary_keys() IShow_primary_keysContext + Show_procedures() IShow_proceduresContext + Show_regions() IShow_regionsContext + Show_replication_accounts() IShow_replication_accountsContext + Show_replication_databases() IShow_replication_databasesContext + Show_replication_groups() IShow_replication_groupsContext + Show_resource_monitors() IShow_resource_monitorsContext + Show_roles() IShow_rolesContext + Show_row_access_policies() IShow_row_access_policiesContext + Show_schemas() IShow_schemasContext + Show_sequences() IShow_sequencesContext + Show_session_policies() IShow_session_policiesContext + Show_shares() IShow_sharesContext + Show_shares_in_failover_group() IShow_shares_in_failover_groupContext + Show_shares_in_replication_group() IShow_shares_in_replication_groupContext + Show_stages() IShow_stagesContext + Show_streams() IShow_streamsContext + Show_tables() IShow_tablesContext + Show_tags() IShow_tagsContext + Show_tasks() IShow_tasksContext + Show_transactions() IShow_transactionsContext + Show_user_functions() IShow_user_functionsContext + Show_users() IShow_usersContext + Show_variables() IShow_variablesContext + Show_views() IShow_viewsContext + Show_warehouses() IShow_warehousesContext + + // IsShow_commandContext differentiates from other interfaces. + IsShow_commandContext() +} + +type Show_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_commandContext() *Show_commandContext { + var p = new(Show_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_command + return p +} + +func InitEmptyShow_commandContext(p *Show_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_command +} + +func (*Show_commandContext) IsShow_commandContext() {} + +func NewShow_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_commandContext { + var p = new(Show_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_command + + return p +} + +func (s *Show_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_commandContext) Show_alerts() IShow_alertsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_alertsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_alertsContext) +} + +func (s *Show_commandContext) Show_columns() IShow_columnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_columnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_columnsContext) +} + +func (s *Show_commandContext) Show_connections() IShow_connectionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_connectionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_connectionsContext) +} + +func (s *Show_commandContext) Show_databases() IShow_databasesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_databasesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_databasesContext) +} + +func (s *Show_commandContext) Show_databases_in_failover_group() IShow_databases_in_failover_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_databases_in_failover_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_databases_in_failover_groupContext) +} + +func (s *Show_commandContext) Show_databases_in_replication_group() IShow_databases_in_replication_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_databases_in_replication_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_databases_in_replication_groupContext) +} + +func (s *Show_commandContext) Show_delegated_authorizations() IShow_delegated_authorizationsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_delegated_authorizationsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_delegated_authorizationsContext) +} + +func (s *Show_commandContext) Show_external_functions() IShow_external_functionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_external_functionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_external_functionsContext) +} + +func (s *Show_commandContext) Show_dynamic_tables() IShow_dynamic_tablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_dynamic_tablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_dynamic_tablesContext) +} + +func (s *Show_commandContext) Show_external_tables() IShow_external_tablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_external_tablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_external_tablesContext) +} + +func (s *Show_commandContext) Show_failover_groups() IShow_failover_groupsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_failover_groupsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_failover_groupsContext) +} + +func (s *Show_commandContext) Show_file_formats() IShow_file_formatsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_file_formatsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_file_formatsContext) +} + +func (s *Show_commandContext) Show_functions() IShow_functionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_functionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_functionsContext) +} + +func (s *Show_commandContext) Show_global_accounts() IShow_global_accountsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_global_accountsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_global_accountsContext) +} + +func (s *Show_commandContext) Show_grants() IShow_grantsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_grantsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_grantsContext) +} + +func (s *Show_commandContext) Show_integrations() IShow_integrationsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_integrationsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_integrationsContext) +} + +func (s *Show_commandContext) Show_locks() IShow_locksContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_locksContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_locksContext) +} + +func (s *Show_commandContext) Show_managed_accounts() IShow_managed_accountsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_managed_accountsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_managed_accountsContext) +} + +func (s *Show_commandContext) Show_masking_policies() IShow_masking_policiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_masking_policiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_masking_policiesContext) +} + +func (s *Show_commandContext) Show_materialized_views() IShow_materialized_viewsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_materialized_viewsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_materialized_viewsContext) +} + +func (s *Show_commandContext) Show_network_policies() IShow_network_policiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_network_policiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_network_policiesContext) +} + +func (s *Show_commandContext) Show_objects() IShow_objectsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_objectsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_objectsContext) +} + +func (s *Show_commandContext) Show_organization_accounts() IShow_organization_accountsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_organization_accountsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_organization_accountsContext) +} + +func (s *Show_commandContext) Show_parameters() IShow_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_parametersContext) +} + +func (s *Show_commandContext) Show_pipes() IShow_pipesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_pipesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_pipesContext) +} + +func (s *Show_commandContext) Show_primary_keys() IShow_primary_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_primary_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_primary_keysContext) +} + +func (s *Show_commandContext) Show_procedures() IShow_proceduresContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_proceduresContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_proceduresContext) +} + +func (s *Show_commandContext) Show_regions() IShow_regionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_regionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_regionsContext) +} + +func (s *Show_commandContext) Show_replication_accounts() IShow_replication_accountsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_replication_accountsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_replication_accountsContext) +} + +func (s *Show_commandContext) Show_replication_databases() IShow_replication_databasesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_replication_databasesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_replication_databasesContext) +} + +func (s *Show_commandContext) Show_replication_groups() IShow_replication_groupsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_replication_groupsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_replication_groupsContext) +} + +func (s *Show_commandContext) Show_resource_monitors() IShow_resource_monitorsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_resource_monitorsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_resource_monitorsContext) +} + +func (s *Show_commandContext) Show_roles() IShow_rolesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_rolesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_rolesContext) +} + +func (s *Show_commandContext) Show_row_access_policies() IShow_row_access_policiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_row_access_policiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_row_access_policiesContext) +} + +func (s *Show_commandContext) Show_schemas() IShow_schemasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_schemasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_schemasContext) +} + +func (s *Show_commandContext) Show_sequences() IShow_sequencesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_sequencesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_sequencesContext) +} + +func (s *Show_commandContext) Show_session_policies() IShow_session_policiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_session_policiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_session_policiesContext) +} + +func (s *Show_commandContext) Show_shares() IShow_sharesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_sharesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_sharesContext) +} + +func (s *Show_commandContext) Show_shares_in_failover_group() IShow_shares_in_failover_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_shares_in_failover_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_shares_in_failover_groupContext) +} + +func (s *Show_commandContext) Show_shares_in_replication_group() IShow_shares_in_replication_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_shares_in_replication_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_shares_in_replication_groupContext) +} + +func (s *Show_commandContext) Show_stages() IShow_stagesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_stagesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_stagesContext) +} + +func (s *Show_commandContext) Show_streams() IShow_streamsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_streamsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_streamsContext) +} + +func (s *Show_commandContext) Show_tables() IShow_tablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_tablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_tablesContext) +} + +func (s *Show_commandContext) Show_tags() IShow_tagsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_tagsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_tagsContext) +} + +func (s *Show_commandContext) Show_tasks() IShow_tasksContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_tasksContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_tasksContext) +} + +func (s *Show_commandContext) Show_transactions() IShow_transactionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_transactionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_transactionsContext) +} + +func (s *Show_commandContext) Show_user_functions() IShow_user_functionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_user_functionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_user_functionsContext) +} + +func (s *Show_commandContext) Show_users() IShow_usersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_usersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_usersContext) +} + +func (s *Show_commandContext) Show_variables() IShow_variablesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_variablesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_variablesContext) +} + +func (s *Show_commandContext) Show_views() IShow_viewsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_viewsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_viewsContext) +} + +func (s *Show_commandContext) Show_warehouses() IShow_warehousesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_warehousesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_warehousesContext) +} + +func (s *Show_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_command(s) + } +} + +func (s *Show_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_command(s) + } +} + +func (s *Show_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_command() (localctx IShow_commandContext) { + localctx = NewShow_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 714, SnowflakeParserRULE_show_command) + p.SetState(9785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1214, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9734) + p.Show_alerts() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9735) + p.Show_columns() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9736) + p.Show_connections() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9737) + p.Show_databases() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9738) + p.Show_databases_in_failover_group() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9739) + p.Show_databases_in_replication_group() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9740) + p.Show_delegated_authorizations() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9741) + p.Show_external_functions() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9742) + p.Show_dynamic_tables() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9743) + p.Show_external_tables() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9744) + p.Show_failover_groups() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9745) + p.Show_file_formats() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(9746) + p.Show_functions() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(9747) + p.Show_global_accounts() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(9748) + p.Show_grants() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(9749) + p.Show_integrations() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(9750) + p.Show_locks() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(9751) + p.Show_managed_accounts() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(9752) + p.Show_masking_policies() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(9753) + p.Show_materialized_views() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(9754) + p.Show_network_policies() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(9755) + p.Show_objects() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(9756) + p.Show_organization_accounts() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(9757) + p.Show_parameters() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(9758) + p.Show_pipes() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(9759) + p.Show_primary_keys() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(9760) + p.Show_procedures() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(9761) + p.Show_regions() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(9762) + p.Show_replication_accounts() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(9763) + p.Show_replication_databases() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(9764) + p.Show_replication_groups() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(9765) + p.Show_resource_monitors() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(9766) + p.Show_roles() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(9767) + p.Show_row_access_policies() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(9768) + p.Show_schemas() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(9769) + p.Show_sequences() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(9770) + p.Show_session_policies() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(9771) + p.Show_shares() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(9772) + p.Show_shares_in_failover_group() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(9773) + p.Show_shares_in_replication_group() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(9774) + p.Show_stages() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(9775) + p.Show_streams() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(9776) + p.Show_tables() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(9777) + p.Show_tags() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(9778) + p.Show_tasks() + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(9779) + p.Show_transactions() + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(9780) + p.Show_user_functions() + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(9781) + p.Show_users() + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(9782) + p.Show_variables() + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(9783) + p.Show_views() + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(9784) + p.Show_warehouses() + } + + 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 +} + +// IShow_alertsContext is an interface to support dynamic dispatch. +type IShow_alertsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + ALERTS() antlr.TerminalNode + TERSE() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + Starts_with() IStarts_withContext + Limit_rows() ILimit_rowsContext + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Id_() IId_Context + Schema_name() ISchema_nameContext + + // IsShow_alertsContext differentiates from other interfaces. + IsShow_alertsContext() +} + +type Show_alertsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_alertsContext() *Show_alertsContext { + var p = new(Show_alertsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_alerts + return p +} + +func InitEmptyShow_alertsContext(p *Show_alertsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_alerts +} + +func (*Show_alertsContext) IsShow_alertsContext() {} + +func NewShow_alertsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_alertsContext { + var p = new(Show_alertsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_alerts + + return p +} + +func (s *Show_alertsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_alertsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_alertsContext) ALERTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERTS, 0) +} + +func (s *Show_alertsContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Show_alertsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_alertsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_alertsContext) Starts_with() IStarts_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStarts_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStarts_withContext) +} + +func (s *Show_alertsContext) Limit_rows() ILimit_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_rowsContext) +} + +func (s *Show_alertsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_alertsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_alertsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_alertsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_alertsContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_alertsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_alertsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_alertsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_alerts(s) + } +} + +func (s *Show_alertsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_alerts(s) + } +} + +func (s *Show_alertsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_alerts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_alerts() (localctx IShow_alertsContext) { + localctx = NewShow_alertsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 716, SnowflakeParserRULE_show_alerts) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9787) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTERSE { + { + p.SetState(9788) + p.Match(SnowflakeParserTERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9791) + p.Match(SnowflakeParserALERTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(9792) + p.Like_pattern() + } + + } + p.SetState(9807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(9795) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT: + { + p.SetState(9796) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(9797) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9799) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1217, p.GetParserRuleContext()) == 1 { + { + p.SetState(9798) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserSCHEMA: + { + p.SetState(9801) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9803) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1218, p.GetParserRuleContext()) == 1 { + { + p.SetState(9802) + p.Schema_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(9810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTARTS { + { + p.SetState(9809) + p.Starts_with() + } + + } + p.SetState(9813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIMIT { + { + p.SetState(9812) + p.Limit_rows() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_columnsContext is an interface to support dynamic dispatch. +type IShow_columnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + VIEW() antlr.TerminalNode + Id_() IId_Context + Schema_name() ISchema_nameContext + + // IsShow_columnsContext differentiates from other interfaces. + IsShow_columnsContext() +} + +type Show_columnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_columnsContext() *Show_columnsContext { + var p = new(Show_columnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_columns + return p +} + +func InitEmptyShow_columnsContext(p *Show_columnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_columns +} + +func (*Show_columnsContext) IsShow_columnsContext() {} + +func NewShow_columnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_columnsContext { + var p = new(Show_columnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_columns + + return p +} + +func (s *Show_columnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_columnsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_columnsContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMNS, 0) +} + +func (s *Show_columnsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_columnsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_columnsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_columnsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_columnsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_columnsContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Show_columnsContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Show_columnsContext) VIEW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW, 0) +} + +func (s *Show_columnsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_columnsContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_columnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_columnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_columnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_columns(s) + } +} + +func (s *Show_columnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_columns(s) + } +} + +func (s *Show_columnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_columns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_columns() (localctx IShow_columnsContext) { + localctx = NewShow_columnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 718, SnowflakeParserRULE_show_columns) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9815) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9816) + p.Match(SnowflakeParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(9817) + p.Like_pattern() + } + + } + p.SetState(9842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(9820) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1228, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9821) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(9822) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(9823) + p.Id_() + } + + } + + case 3: + { + p.SetState(9826) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(9827) + p.Schema_name() + } + + } + + case 4: + { + p.SetState(9830) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.SetState(9832) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTABLE { + { + p.SetState(9831) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9834) + p.Object_name() + } + + case 6: + { + p.SetState(9835) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.SetState(9837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserVIEW { + { + p.SetState(9836) + p.Match(SnowflakeParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9839) + p.Object_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 +} + +// IShow_connectionsContext is an interface to support dynamic dispatch. +type IShow_connectionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + CONNECTIONS() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_connectionsContext differentiates from other interfaces. + IsShow_connectionsContext() +} + +type Show_connectionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_connectionsContext() *Show_connectionsContext { + var p = new(Show_connectionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_connections + return p +} + +func InitEmptyShow_connectionsContext(p *Show_connectionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_connections +} + +func (*Show_connectionsContext) IsShow_connectionsContext() {} + +func NewShow_connectionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_connectionsContext { + var p = new(Show_connectionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_connections + + return p +} + +func (s *Show_connectionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_connectionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_connectionsContext) CONNECTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONNECTIONS, 0) +} + +func (s *Show_connectionsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_connectionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_connectionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_connectionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_connections(s) + } +} + +func (s *Show_connectionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_connections(s) + } +} + +func (s *Show_connectionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_connections(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_connections() (localctx IShow_connectionsContext) { + localctx = NewShow_connectionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 720, SnowflakeParserRULE_show_connections) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9844) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9845) + p.Match(SnowflakeParserCONNECTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(9846) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStarts_withContext is an interface to support dynamic dispatch. +type IStarts_withContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STARTS() antlr.TerminalNode + WITH() antlr.TerminalNode + String_() IStringContext + + // IsStarts_withContext differentiates from other interfaces. + IsStarts_withContext() +} + +type Starts_withContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStarts_withContext() *Starts_withContext { + var p = new(Starts_withContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_starts_with + return p +} + +func InitEmptyStarts_withContext(p *Starts_withContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_starts_with +} + +func (*Starts_withContext) IsStarts_withContext() {} + +func NewStarts_withContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Starts_withContext { + var p = new(Starts_withContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_starts_with + + return p +} + +func (s *Starts_withContext) GetParser() antlr.Parser { return s.parser } + +func (s *Starts_withContext) STARTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTARTS, 0) +} + +func (s *Starts_withContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Starts_withContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Starts_withContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Starts_withContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Starts_withContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterStarts_with(s) + } +} + +func (s *Starts_withContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitStarts_with(s) + } +} + +func (s *Starts_withContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitStarts_with(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Starts_with() (localctx IStarts_withContext) { + localctx = NewStarts_withContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 722, SnowflakeParserRULE_starts_with) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9849) + p.Match(SnowflakeParserSTARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9850) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9851) + p.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 +} + +// ILimit_rowsContext is an interface to support dynamic dispatch. +type ILimit_rowsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIMIT() antlr.TerminalNode + Num() INumContext + FROM() antlr.TerminalNode + String_() IStringContext + + // IsLimit_rowsContext differentiates from other interfaces. + IsLimit_rowsContext() +} + +type Limit_rowsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLimit_rowsContext() *Limit_rowsContext { + var p = new(Limit_rowsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_limit_rows + return p +} + +func InitEmptyLimit_rowsContext(p *Limit_rowsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_limit_rows +} + +func (*Limit_rowsContext) IsLimit_rowsContext() {} + +func NewLimit_rowsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Limit_rowsContext { + var p = new(Limit_rowsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_limit_rows + + return p +} + +func (s *Limit_rowsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Limit_rowsContext) LIMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIMIT, 0) +} + +func (s *Limit_rowsContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Limit_rowsContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Limit_rowsContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Limit_rowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Limit_rowsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Limit_rowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterLimit_rows(s) + } +} + +func (s *Limit_rowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitLimit_rows(s) + } +} + +func (s *Limit_rowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitLimit_rows(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Limit_rows() (localctx ILimit_rowsContext) { + localctx = NewLimit_rowsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 724, SnowflakeParserRULE_limit_rows) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9853) + p.Match(SnowflakeParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9854) + p.Num() + } + p.SetState(9857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFROM { + { + p.SetState(9855) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9856) + p.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 +} + +// IShow_databasesContext is an interface to support dynamic dispatch. +type IShow_databasesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + DATABASES() antlr.TerminalNode + TERSE() antlr.TerminalNode + HISTORY() antlr.TerminalNode + Like_pattern() ILike_patternContext + Starts_with() IStarts_withContext + Limit_rows() ILimit_rowsContext + + // IsShow_databasesContext differentiates from other interfaces. + IsShow_databasesContext() +} + +type Show_databasesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_databasesContext() *Show_databasesContext { + var p = new(Show_databasesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_databases + return p +} + +func InitEmptyShow_databasesContext(p *Show_databasesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_databases +} + +func (*Show_databasesContext) IsShow_databasesContext() {} + +func NewShow_databasesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_databasesContext { + var p = new(Show_databasesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_databases + + return p +} + +func (s *Show_databasesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_databasesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_databasesContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Show_databasesContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Show_databasesContext) HISTORY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHISTORY, 0) +} + +func (s *Show_databasesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_databasesContext) Starts_with() IStarts_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStarts_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStarts_withContext) +} + +func (s *Show_databasesContext) Limit_rows() ILimit_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_rowsContext) +} + +func (s *Show_databasesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_databasesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_databasesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_databases(s) + } +} + +func (s *Show_databasesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_databases(s) + } +} + +func (s *Show_databasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_databases(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_databases() (localctx IShow_databasesContext) { + localctx = NewShow_databasesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 726, SnowflakeParserRULE_show_databases) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9859) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTERSE { + { + p.SetState(9860) + p.Match(SnowflakeParserTERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9863) + p.Match(SnowflakeParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserHISTORY { + { + p.SetState(9864) + p.Match(SnowflakeParserHISTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(9867) + p.Like_pattern() + } + + } + p.SetState(9871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTARTS { + { + p.SetState(9870) + p.Starts_with() + } + + } + p.SetState(9874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIMIT { + { + p.SetState(9873) + p.Limit_rows() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_databases_in_failover_groupContext is an interface to support dynamic dispatch. +type IShow_databases_in_failover_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + DATABASES() antlr.TerminalNode + IN() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + + // IsShow_databases_in_failover_groupContext differentiates from other interfaces. + IsShow_databases_in_failover_groupContext() +} + +type Show_databases_in_failover_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_databases_in_failover_groupContext() *Show_databases_in_failover_groupContext { + var p = new(Show_databases_in_failover_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_databases_in_failover_group + return p +} + +func InitEmptyShow_databases_in_failover_groupContext(p *Show_databases_in_failover_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_databases_in_failover_group +} + +func (*Show_databases_in_failover_groupContext) IsShow_databases_in_failover_groupContext() {} + +func NewShow_databases_in_failover_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_databases_in_failover_groupContext { + var p = new(Show_databases_in_failover_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_databases_in_failover_group + + return p +} + +func (s *Show_databases_in_failover_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_databases_in_failover_groupContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_databases_in_failover_groupContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Show_databases_in_failover_groupContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_databases_in_failover_groupContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, 0) +} + +func (s *Show_databases_in_failover_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Show_databases_in_failover_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_databases_in_failover_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_databases_in_failover_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_databases_in_failover_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_databases_in_failover_group(s) + } +} + +func (s *Show_databases_in_failover_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_databases_in_failover_group(s) + } +} + +func (s *Show_databases_in_failover_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_databases_in_failover_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_databases_in_failover_group() (localctx IShow_databases_in_failover_groupContext) { + localctx = NewShow_databases_in_failover_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 728, SnowflakeParserRULE_show_databases_in_failover_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9876) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9877) + p.Match(SnowflakeParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9878) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9879) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9880) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9881) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_databases_in_replication_groupContext is an interface to support dynamic dispatch. +type IShow_databases_in_replication_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + DATABASES() antlr.TerminalNode + IN() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + + // IsShow_databases_in_replication_groupContext differentiates from other interfaces. + IsShow_databases_in_replication_groupContext() +} + +type Show_databases_in_replication_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_databases_in_replication_groupContext() *Show_databases_in_replication_groupContext { + var p = new(Show_databases_in_replication_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_databases_in_replication_group + return p +} + +func InitEmptyShow_databases_in_replication_groupContext(p *Show_databases_in_replication_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_databases_in_replication_group +} + +func (*Show_databases_in_replication_groupContext) IsShow_databases_in_replication_groupContext() {} + +func NewShow_databases_in_replication_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_databases_in_replication_groupContext { + var p = new(Show_databases_in_replication_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_databases_in_replication_group + + return p +} + +func (s *Show_databases_in_replication_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_databases_in_replication_groupContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_databases_in_replication_groupContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Show_databases_in_replication_groupContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_databases_in_replication_groupContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Show_databases_in_replication_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Show_databases_in_replication_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_databases_in_replication_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_databases_in_replication_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_databases_in_replication_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_databases_in_replication_group(s) + } +} + +func (s *Show_databases_in_replication_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_databases_in_replication_group(s) + } +} + +func (s *Show_databases_in_replication_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_databases_in_replication_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_databases_in_replication_group() (localctx IShow_databases_in_replication_groupContext) { + localctx = NewShow_databases_in_replication_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 730, SnowflakeParserRULE_show_databases_in_replication_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9883) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9884) + p.Match(SnowflakeParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9885) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9886) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9887) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9888) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_delegated_authorizationsContext is an interface to support dynamic dispatch. +type IShow_delegated_authorizationsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + DELEGATED() antlr.TerminalNode + AUTHORIZATIONS() antlr.TerminalNode + BY() antlr.TerminalNode + USER() antlr.TerminalNode + Id_() IId_Context + TO() antlr.TerminalNode + SECURITY() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + + // IsShow_delegated_authorizationsContext differentiates from other interfaces. + IsShow_delegated_authorizationsContext() +} + +type Show_delegated_authorizationsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_delegated_authorizationsContext() *Show_delegated_authorizationsContext { + var p = new(Show_delegated_authorizationsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_delegated_authorizations + return p +} + +func InitEmptyShow_delegated_authorizationsContext(p *Show_delegated_authorizationsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_delegated_authorizations +} + +func (*Show_delegated_authorizationsContext) IsShow_delegated_authorizationsContext() {} + +func NewShow_delegated_authorizationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_delegated_authorizationsContext { + var p = new(Show_delegated_authorizationsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_delegated_authorizations + + return p +} + +func (s *Show_delegated_authorizationsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_delegated_authorizationsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_delegated_authorizationsContext) DELEGATED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELEGATED, 0) +} + +func (s *Show_delegated_authorizationsContext) AUTHORIZATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTHORIZATIONS, 0) +} + +func (s *Show_delegated_authorizationsContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Show_delegated_authorizationsContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Show_delegated_authorizationsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_delegated_authorizationsContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Show_delegated_authorizationsContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Show_delegated_authorizationsContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Show_delegated_authorizationsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_delegated_authorizationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_delegated_authorizationsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_delegated_authorizations(s) + } +} + +func (s *Show_delegated_authorizationsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_delegated_authorizations(s) + } +} + +func (s *Show_delegated_authorizationsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_delegated_authorizations(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_delegated_authorizations() (localctx IShow_delegated_authorizationsContext) { + localctx = NewShow_delegated_authorizationsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 732, SnowflakeParserRULE_show_delegated_authorizations) + p.SetState(9906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1237, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9890) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9891) + p.Match(SnowflakeParserDELEGATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9892) + p.Match(SnowflakeParserAUTHORIZATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9893) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9894) + p.Match(SnowflakeParserDELEGATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9895) + p.Match(SnowflakeParserAUTHORIZATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9896) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9897) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9898) + p.Id_() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9899) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9900) + p.Match(SnowflakeParserDELEGATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9901) + p.Match(SnowflakeParserAUTHORIZATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9902) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9903) + p.Match(SnowflakeParserSECURITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9904) + p.Match(SnowflakeParserINTEGRATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9905) + p.Id_() + } + + 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 +} + +// IShow_external_functionsContext is an interface to support dynamic dispatch. +type IShow_external_functionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_external_functionsContext differentiates from other interfaces. + IsShow_external_functionsContext() +} + +type Show_external_functionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_external_functionsContext() *Show_external_functionsContext { + var p = new(Show_external_functionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_external_functions + return p +} + +func InitEmptyShow_external_functionsContext(p *Show_external_functionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_external_functions +} + +func (*Show_external_functionsContext) IsShow_external_functionsContext() {} + +func NewShow_external_functionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_external_functionsContext { + var p = new(Show_external_functionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_external_functions + + return p +} + +func (s *Show_external_functionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_external_functionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_external_functionsContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Show_external_functionsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTIONS, 0) +} + +func (s *Show_external_functionsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_external_functionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_external_functionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_external_functionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_external_functions(s) + } +} + +func (s *Show_external_functionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_external_functions(s) + } +} + +func (s *Show_external_functionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_external_functions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_external_functions() (localctx IShow_external_functionsContext) { + localctx = NewShow_external_functionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 734, SnowflakeParserRULE_show_external_functions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9908) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9909) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9910) + p.Match(SnowflakeParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(9911) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_dynamic_tablesContext is an interface to support dynamic dispatch. +type IShow_dynamic_tablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + TABLES() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + Starts_with() IStarts_withContext + Limit_rows() ILimit_rowsContext + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsShow_dynamic_tablesContext differentiates from other interfaces. + IsShow_dynamic_tablesContext() +} + +type Show_dynamic_tablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_dynamic_tablesContext() *Show_dynamic_tablesContext { + var p = new(Show_dynamic_tablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_dynamic_tables + return p +} + +func InitEmptyShow_dynamic_tablesContext(p *Show_dynamic_tablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_dynamic_tables +} + +func (*Show_dynamic_tablesContext) IsShow_dynamic_tablesContext() {} + +func NewShow_dynamic_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_dynamic_tablesContext { + var p = new(Show_dynamic_tablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_dynamic_tables + + return p +} + +func (s *Show_dynamic_tablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_dynamic_tablesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_dynamic_tablesContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDYNAMIC, 0) +} + +func (s *Show_dynamic_tablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLES, 0) +} + +func (s *Show_dynamic_tablesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_dynamic_tablesContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_dynamic_tablesContext) Starts_with() IStarts_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStarts_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStarts_withContext) +} + +func (s *Show_dynamic_tablesContext) Limit_rows() ILimit_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_rowsContext) +} + +func (s *Show_dynamic_tablesContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_dynamic_tablesContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_dynamic_tablesContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_dynamic_tablesContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_dynamic_tablesContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_dynamic_tablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_dynamic_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_dynamic_tablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_dynamic_tables(s) + } +} + +func (s *Show_dynamic_tablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_dynamic_tables(s) + } +} + +func (s *Show_dynamic_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_dynamic_tables(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_dynamic_tables() (localctx IShow_dynamic_tablesContext) { + localctx = NewShow_dynamic_tablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 736, SnowflakeParserRULE_show_dynamic_tables) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9914) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9915) + p.Match(SnowflakeParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9916) + p.Match(SnowflakeParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(9917) + p.Like_pattern() + } + + } + p.SetState(9934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(9920) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT: + { + p.SetState(9921) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(9922) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9924) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1240, p.GetParserRuleContext()) == 1 { + { + p.SetState(9923) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserEOF, SnowflakeParserAAD_PROVISIONER_Q, SnowflakeParserABORT, SnowflakeParserABORT_AFTER_WAIT, SnowflakeParserABORT_DETACHED_QUERY, SnowflakeParserABORT_STATEMENT, SnowflakeParserABSENT, SnowflakeParserABSOLUTE, SnowflakeParserACCESS, SnowflakeParserACCOUNTADMIN, SnowflakeParserACCOUNTS, SnowflakeParserACTION, SnowflakeParserACTIVE, SnowflakeParserADD, SnowflakeParserADMINISTER, SnowflakeParserADMIN_NAME, SnowflakeParserADMIN_PASSWORD, SnowflakeParserAES, SnowflakeParserAFTER, SnowflakeParserAGGREGATE, SnowflakeParserALERT, SnowflakeParserALERTS, SnowflakeParserALLOWED, SnowflakeParserALLOWED_ACCOUNTS, SnowflakeParserALLOWED_DATABASES, SnowflakeParserALLOWED_INTEGRATION_TYPES, SnowflakeParserALLOWED_IP_LIST, SnowflakeParserALLOWED_SHARES, SnowflakeParserALLOWED_VALUES, SnowflakeParserALLOW_CLIENT_MFA_CACHING, SnowflakeParserALLOW_CONNECTIONS, SnowflakeParserALLOW_DUPLICATE, SnowflakeParserALLOW_ID_TOKEN, SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, SnowflakeParserALLOW_OVERLAPPING_EXECUTION, SnowflakeParserALLOW_SINGLE_EVENT_LOSS, SnowflakeParserALWAYS, SnowflakeParserANONYMOUS, SnowflakeParserANSI_DEFAULTS, SnowflakeParserAPI, SnowflakeParserAPI_ALLOWED_PREFIXES, SnowflakeParserAPI_AWS_ROLE_ARN, SnowflakeParserAPI_BLOCKED_PREFIXES, SnowflakeParserAPI_INTEGRATION, SnowflakeParserAPI_KEY, SnowflakeParserAPI_PROVIDER, SnowflakeParserAPPEND, SnowflakeParserAPPEND_ONLY, SnowflakeParserAPPLICATION, SnowflakeParserAPPLY, SnowflakeParserAPP_NAME, SnowflakeParserASC, SnowflakeParserATTACH, SnowflakeParserAT_KEYWORD, SnowflakeParserAUTHORIZATION, SnowflakeParserAUTHORIZATIONS, SnowflakeParserAUTO, SnowflakeParserAUTO_Q, SnowflakeParserAUTOCOMMIT, SnowflakeParserAUTOCOMMIT_API_SUPPORTED, SnowflakeParserAUTOINCREMENT, SnowflakeParserAUTO_COMPRESS, SnowflakeParserAUTO_DETECT, SnowflakeParserAUTO_INGEST, SnowflakeParserAUTO_REFRESH, SnowflakeParserAUTO_RESUME, SnowflakeParserAUTO_SUSPEND, SnowflakeParserAVG, SnowflakeParserAVRO, SnowflakeParserAVRO_Q, SnowflakeParserAWS_KEY_ID, SnowflakeParserAWS_ROLE, SnowflakeParserAWS_SECRET_KEY, SnowflakeParserAWS_SNS, SnowflakeParserAWS_SNS_ROLE_ARN, SnowflakeParserAWS_SNS_TOPIC, SnowflakeParserAWS_SNS_TOPIC_ARN, SnowflakeParserAWS_TOKEN, SnowflakeParserAZURE, SnowflakeParserAZURE_AD_APPLICATION_ID, SnowflakeParserAZURE_EVENT_GRID, SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, SnowflakeParserAZURE_Q, SnowflakeParserAZURE_SAS_TOKEN, SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, SnowflakeParserAZURE_TENANT_ID, SnowflakeParserBEFORE, SnowflakeParserBEGIN, SnowflakeParserBERNOULLI, SnowflakeParserBINARY_AS_TEXT, SnowflakeParserBINARY_CHECKSUM, SnowflakeParserBINARY_FORMAT, SnowflakeParserBINARY_INPUT_FORMAT, SnowflakeParserBINARY_OUTPUT_FORMAT, SnowflakeParserBINDING, SnowflakeParserBLOCK, SnowflakeParserBLOCKED_IP_LIST, SnowflakeParserBLOCKED_ROLES_LIST, SnowflakeParserBODY, SnowflakeParserBOTH_Q, SnowflakeParserBROTLI, SnowflakeParserBUSINESS_CRITICAL, SnowflakeParserCACHE, SnowflakeParserCALL, SnowflakeParserCALLED, SnowflakeParserCALLER, SnowflakeParserCASCADE, SnowflakeParserCASE_INSENSITIVE, SnowflakeParserCASE_SENSITIVE, SnowflakeParserCATCH, SnowflakeParserCERTIFICATE, SnowflakeParserCHANGE, SnowflakeParserCHANGES, SnowflakeParserCHANGETABLE, SnowflakeParserCHANGE_RETENTION, SnowflakeParserCHANGE_TRACKING, SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserCHARINDEX, SnowflakeParserCHECKSUM, SnowflakeParserCHECKSUM_AGG, SnowflakeParserCHECK_EXPIRATION, SnowflakeParserCHECK_POLICY, SnowflakeParserCLASSIFIER_FUNCTION, SnowflakeParserCLEANUP, SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, SnowflakeParserCLIENT_MEMORY_LIMIT, SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, SnowflakeParserCLIENT_PREFETCH_THREADS, SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, SnowflakeParserCLONE, SnowflakeParserCLOSE, SnowflakeParserCLUSTER, SnowflakeParserCLUSTERED, SnowflakeParserCLUSTERING, SnowflakeParserCOALESCE, SnowflakeParserCOLLATE, SnowflakeParserCOLLECTION, SnowflakeParserCOLUMNS, SnowflakeParserCOL_LENGTH, SnowflakeParserCOL_NAME, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOMMITTED, SnowflakeParserCOMPRESS, SnowflakeParserCOMPRESSION, SnowflakeParserCONCAT, SnowflakeParserCONCAT_NULL_YIELDS_NULL, SnowflakeParserCONCAT_WS, SnowflakeParserCONDITION, SnowflakeParserCONFIGURATION, SnowflakeParserCONNECTIONS, SnowflakeParserCONTAINMENT, SnowflakeParserCONTAINS, SnowflakeParserCONTENT, SnowflakeParserCONTEXT, SnowflakeParserCONTEXT_HEADERS, SnowflakeParserCONTEXT_INFO, SnowflakeParserCONTINUE, SnowflakeParserCONTROL, SnowflakeParserCONVERSATION, SnowflakeParserCOOKIE, SnowflakeParserCOPY, SnowflakeParserCOPY_ONLY, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserCOUNT, SnowflakeParserCOUNT_BIG, SnowflakeParserCREDENTIALS, SnowflakeParserCREDIT_QUOTA, SnowflakeParserCSV, SnowflakeParserCSV_Q, SnowflakeParserCUBE, SnowflakeParserCUME_DIST, SnowflakeParserCURRENT_DATE, SnowflakeParserCURRENT_TIMESTAMP, SnowflakeParserCURSOR, SnowflakeParserCUSTOM, SnowflakeParserDAILY, SnowflakeParserDATA, SnowflakeParserDATABASES, SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, SnowflakeParserDATEADD, SnowflakeParserDATEDIFF, SnowflakeParserDATENAME, SnowflakeParserDATEPART, SnowflakeParserDATE_FORMAT, SnowflakeParserDATE_INPUT_FORMAT, SnowflakeParserDATE_OUTPUT_FORMAT, SnowflakeParserDATE_PART, SnowflakeParserDAYS, SnowflakeParserDAYS_TO_EXPIRY, SnowflakeParserDECLARE, SnowflakeParserDEFAULT, SnowflakeParserDEFAULT_DDL_COLLATION_, SnowflakeParserDEFAULT_NAMESPACE, SnowflakeParserDEFAULT_ROLE, SnowflakeParserDEFAULT_WAREHOUSE, SnowflakeParserDEFERRABLE, SnowflakeParserDEFERRED, SnowflakeParserDEFINE, SnowflakeParserDEFINITION, SnowflakeParserDEFLATE, SnowflakeParserDELEGATED, SnowflakeParserDELTA, SnowflakeParserDENSE_RANK, SnowflakeParserDESC, SnowflakeParserDESCRIBE, SnowflakeParserDIRECTION, SnowflakeParserDIRECTORY, SnowflakeParserDISABLE, SnowflakeParserDISABLED, SnowflakeParserDISABLE_AUTO_CONVERT, SnowflakeParserDISABLE_SNOWFLAKE_DATA, SnowflakeParserDISK, SnowflakeParserDISPLAY_NAME, SnowflakeParserDO, SnowflakeParserDOWNSTREAM, SnowflakeParserDOUBLE, SnowflakeParserDYNAMIC, SnowflakeParserECONOMY, SnowflakeParserEDITION, SnowflakeParserEMAIL, SnowflakeParserEMPTY_, SnowflakeParserEMPTY_FIELD_AS_NULL, SnowflakeParserENABLE, SnowflakeParserENABLED, SnowflakeParserENABLE_FOR_PRIVILEGE, SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, SnowflakeParserENABLE_OCTAL, SnowflakeParserENABLE_QUERY_ACCELERATION, SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, SnowflakeParserENCODING, SnowflakeParserENCRYPTION, SnowflakeParserEND, SnowflakeParserENDPOINT, SnowflakeParserEND_TIMESTAMP, SnowflakeParserENFORCED, SnowflakeParserENFORCE_LENGTH, SnowflakeParserENFORCE_SESSION_POLICY, SnowflakeParserENTERPRISE, SnowflakeParserEQUALITY, SnowflakeParserERROR_INTEGRATION, SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, SnowflakeParserESCAPE, SnowflakeParserESCAPE_UNENCLOSED_FIELD, SnowflakeParserEXCEPT, SnowflakeParserEXCHANGE, SnowflakeParserEXECUTE, SnowflakeParserEXECUTION, SnowflakeParserEXIST, SnowflakeParserEXIT, SnowflakeParserEXPAND, SnowflakeParserEXPIRY_DATE, SnowflakeParserEXPLAIN, SnowflakeParserEXPLICIT, SnowflakeParserEXTERNAL, SnowflakeParserEXTERNAL_OAUTH, SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ISSUER, SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, SnowflakeParserEXTERNAL_OAUTH_TYPE, SnowflakeParserEXTERNAL_STAGE, SnowflakeParserFAILOVER, SnowflakeParserFAILOVER_MODE, SnowflakeParserFAIL_OPERATION, SnowflakeParserFETCH, SnowflakeParserFIELD_DELIMITER, SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, SnowflakeParserFILE, SnowflakeParserFILES, SnowflakeParserFILE_EXTENSION, SnowflakeParserFILE_FORMAT, SnowflakeParserFILTER, SnowflakeParserFIRST, SnowflakeParserFIRST_NAME, SnowflakeParserFLATTEN, SnowflakeParserFORCE, SnowflakeParserFOREIGN, SnowflakeParserFORMAT, SnowflakeParserFORMATS, SnowflakeParserFORMAT_NAME, SnowflakeParserFREQUENCY, SnowflakeParserFUNCTION, SnowflakeParserFUNCTIONS, SnowflakeParserFUTURE, SnowflakeParserGCP_PUBSUB, SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, SnowflakeParserGCP_PUBSUB_TOPIC_NAME, SnowflakeParserGCS, SnowflakeParserGENERIC_Q, SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, SnowflakeParserGEO, SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, SnowflakeParserGEOMETRY_OUTPUT_FORMAT, SnowflakeParserGET, SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, SnowflakeParserGLOBAL, SnowflakeParserGOOGLE_AUDIENCE, SnowflakeParserGOTO, SnowflakeParserGRANTS, SnowflakeParserGROUPING, SnowflakeParserGROUPING_ID, SnowflakeParserGROUPS, SnowflakeParserGZIP, SnowflakeParserHEADER, SnowflakeParserHEADERS, SnowflakeParserHEX, SnowflakeParserHIERARCHYID, SnowflakeParserHIGH, SnowflakeParserHISTORY, SnowflakeParserHOURS, SnowflakeParserIDENTITY, SnowflakeParserIF, SnowflakeParserIFF, SnowflakeParserIFNULL, SnowflakeParserIGNORE, SnowflakeParserIGNORE_CONSTRAINTS, SnowflakeParserIGNORE_DUP_KEY, SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, SnowflakeParserIGNORE_TRIGGERS, SnowflakeParserIMMEDIATE, SnowflakeParserIMMEDIATELY, SnowflakeParserIMMUTABLE, SnowflakeParserIMPLICIT, SnowflakeParserIMPORT, SnowflakeParserIMPORTED, SnowflakeParserINDEX, SnowflakeParserINFORMATION, SnowflakeParserINIT, SnowflakeParserINITIALLY, SnowflakeParserINITIALLY_SUSPENDED, SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, SnowflakeParserINPUT, SnowflakeParserINSERT_ONLY, SnowflakeParserINSTEAD, SnowflakeParserINT, SnowflakeParserINTEGRATION, SnowflakeParserINTEGRATIONS, SnowflakeParserISNULL, SnowflakeParserISNUMERIC, SnowflakeParserISOLATION, SnowflakeParserJAVASCRIPT, SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, SnowflakeParserJDBC_USE_SESSION_TIMEZONE, SnowflakeParserJSON, SnowflakeParserJSON_Q, SnowflakeParserJSON_INDENT, SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, SnowflakeParserKB, SnowflakeParserKEEP, SnowflakeParserKEY, SnowflakeParserKEYS, SnowflakeParserKEYSET, SnowflakeParserKMS_KEY_ID, SnowflakeParserLAG, SnowflakeParserLANGUAGE, SnowflakeParserLARGE, SnowflakeParserLAST, SnowflakeParserLAST_NAME, SnowflakeParserLAST_QUERY_ID, SnowflakeParserLAST_VALUE, SnowflakeParserLEAD, SnowflakeParserLEN, SnowflakeParserLENGTH, SnowflakeParserLEVEL, SnowflakeParserLIMIT, SnowflakeParserLINENO, SnowflakeParserLIST, SnowflakeParserLISTENER_IP, SnowflakeParserLISTENER_PORT, SnowflakeParserLISTING, SnowflakeParserLOAD, SnowflakeParserLOCAL, SnowflakeParserLOCAL_SERVICE_NAME, SnowflakeParserLOCATION, SnowflakeParserLOCKS, SnowflakeParserLOCK_TIMEOUT, SnowflakeParserLOG, SnowflakeParserLOGIN, SnowflakeParserLOGIN_NAME, SnowflakeParserLOOKER, SnowflakeParserLOW, SnowflakeParserLOWER, SnowflakeParserLTRIM, SnowflakeParserLZO, SnowflakeParserMANAGE, SnowflakeParserMANAGED, SnowflakeParserMASK, SnowflakeParserMASKED, SnowflakeParserMASKING, SnowflakeParserMASTER, SnowflakeParserMASTER_KEY, SnowflakeParserMATCH, SnowflakeParserMATCHED, SnowflakeParserMATCHES, SnowflakeParserMATCH_BY_COLUMN_NAME, SnowflakeParserMATCH_RECOGNIZE, SnowflakeParserMATERIALIZED, SnowflakeParserMAX_BATCH_ROWS, SnowflakeParserMAX_CLUSTER_COUNT, SnowflakeParserMAX_CONCURRENCY_LEVEL, SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, SnowflakeParserMAX_SIZE, SnowflakeParserMEASURES, SnowflakeParserMEDIUM, SnowflakeParserMEMOIZABLE, SnowflakeParserMERGE, SnowflakeParserMIDDLE_NAME, SnowflakeParserMIN, SnowflakeParserMINS_TO_BYPASS_MFA, SnowflakeParserMINS_TO_UNLOCK, SnowflakeParserMINUS_, SnowflakeParserMINUTES, SnowflakeParserMIN_CLUSTER_COUNT, SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, SnowflakeParserMODE, SnowflakeParserMODIFIED_AFTER, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserMONITORS, SnowflakeParserMONTHLY, SnowflakeParserMOVE, SnowflakeParserMULTI_STATEMENT_COUNT, SnowflakeParserMULTI_USER, SnowflakeParserMUST_CHANGE, SnowflakeParserMUST_CHANGE_PASSWORD, SnowflakeParserNAME, SnowflakeParserNCHAR, SnowflakeParserNESTED_TRIGGERS, SnowflakeParserNETWORK, SnowflakeParserNETWORK_POLICY, SnowflakeParserNEVER, SnowflakeParserNEWID, SnowflakeParserNEWNAME, SnowflakeParserNEWSEQUENTIALID, SnowflakeParserNEW_ACCOUNT, SnowflakeParserNEW_BROKER, SnowflakeParserNEW_PASSWORD, SnowflakeParserNEXT, SnowflakeParserNEXTVAL, SnowflakeParserNO, SnowflakeParserNONE, SnowflakeParserNONE_Q, SnowflakeParserNORELY, SnowflakeParserNOTIFICATION, SnowflakeParserNOTIFICATIONS, SnowflakeParserNOTIFICATION_INTEGRATION, SnowflakeParserNOTIFICATION_PROVIDER, SnowflakeParserNOTIFY, SnowflakeParserNOTIFY_USERS, SnowflakeParserNOVALIDATE, SnowflakeParserNTILE, SnowflakeParserNULLIF, SnowflakeParserNULLS, SnowflakeParserNULL_, SnowflakeParserNULL_IF, SnowflakeParserNUMANODE, SnowflakeParserNUMBER, SnowflakeParserNUMERIC_ROUNDABORT, SnowflakeParserNVL, SnowflakeParserOAUTH, SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, SnowflakeParserOAUTH_CLIENT, SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, SnowflakeParserOAUTH_ENFORCE_PKCE, SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, SnowflakeParserOAUTH_REDIRECT_URI, SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, SnowflakeParserOAUTH_USE_SECONDARY_ROLES, SnowflakeParserOBJECT, SnowflakeParserOBJECT_Q, SnowflakeParserOBJECTS, SnowflakeParserOBJECT_TYPES, SnowflakeParserOFF, SnowflakeParserOFFSET, SnowflakeParserOFFSETS, SnowflakeParserOKTA, SnowflakeParserOKTA_PROVISIONER_Q, SnowflakeParserOKTA_Q, SnowflakeParserOLD, SnowflakeParserOLD_ACCOUNT, SnowflakeParserOLD_PASSWORD, SnowflakeParserOMIT, SnowflakeParserONE, SnowflakeParserONLINE, SnowflakeParserONLY, SnowflakeParserON_ERROR, SnowflakeParserON_FAILURE, SnowflakeParserOPEN, SnowflakeParserOPERATE, SnowflakeParserOPERATIONS, SnowflakeParserOPTIMIZATION, SnowflakeParserOPTION, SnowflakeParserORC, SnowflakeParserORC_Q, SnowflakeParserORGADMIN, SnowflakeParserOUTBOUND, SnowflakeParserOUTER, SnowflakeParserOVER, SnowflakeParserOVERRIDE, SnowflakeParserOVERWRITE, SnowflakeParserOWNER, SnowflakeParserOWNERSHIP, SnowflakeParserPAGE, SnowflakeParserPARALLEL, SnowflakeParserPARAMETERS, SnowflakeParserPARAM_NODE, SnowflakeParserPARQUET, SnowflakeParserPARQUET_Q, SnowflakeParserPARTIAL, SnowflakeParserPARTITION, SnowflakeParserPARTITIONS, SnowflakeParserPARTITION_TYPE, SnowflakeParserPASSWORD, SnowflakeParserPAST, SnowflakeParserPATH_, SnowflakeParserPATTERN, SnowflakeParserPER, SnowflakeParserPERCENT, SnowflakeParserPERCENTILE_CONT, SnowflakeParserPERCENTILE_DISC, SnowflakeParserPERCENT_RANK, SnowflakeParserPERIODIC_DATA_REKEYING, SnowflakeParserPERMISSION_SET, SnowflakeParserPERSISTED, SnowflakeParserPERSIST_SAMPLE_PERCENT, SnowflakeParserPING_FEDERATE, SnowflakeParserPIPE, SnowflakeParserPIPES, SnowflakeParserPIPE_EXECUTION_PAUSED, SnowflakeParserPIVOT, SnowflakeParserPLAN, SnowflakeParserPLATFORM, SnowflakeParserPOLICIES, SnowflakeParserPOLICY, SnowflakeParserPOOL, SnowflakeParserPORT, SnowflakeParserPRECEDING, SnowflakeParserPRECISION, SnowflakeParserPREDICATE, SnowflakeParserPREFIX, SnowflakeParserPRESERVE_SPACE, SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, SnowflakeParserPRIMARY, SnowflakeParserPRIMARY_ROLE, SnowflakeParserPRIOR, SnowflakeParserPRIORITY, SnowflakeParserPRIORITY_LEVEL, SnowflakeParserPRIVATE, SnowflakeParserPRIVATE_KEY, SnowflakeParserPRIVILEGES, SnowflakeParserPROC, SnowflakeParserPROCEDURE, SnowflakeParserPROCEDURES, SnowflakeParserPROCEDURE_NAME, SnowflakeParserPROCESS, SnowflakeParserPROFILE, SnowflakeParserPROPERTY, SnowflakeParserPROVIDER, SnowflakeParserPROVIDER_KEY_NAME, SnowflakeParserPUBLIC, SnowflakeParserPURGE, SnowflakeParserPUT, SnowflakeParserPYTHON, SnowflakeParserQUERIES, SnowflakeParserQUERY, SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, SnowflakeParserQUERY_TAG, SnowflakeParserQUEUE, SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, SnowflakeParserRANGE, SnowflakeParserRANK, SnowflakeParserRAW_DEFLATE, SnowflakeParserREAD, SnowflakeParserREADER, SnowflakeParserREADONLY, SnowflakeParserREADPAST, SnowflakeParserREADTEXT, SnowflakeParserREADWRITE, SnowflakeParserREAD_COMMITTED_SNAPSHOT, SnowflakeParserREAD_ONLY, SnowflakeParserREAD_ONLY_ROUTING_LIST, SnowflakeParserREAD_WRITE, SnowflakeParserREBUILD, SnowflakeParserRECEIVE, SnowflakeParserRECLUSTER, SnowflakeParserRECOMPILE, SnowflakeParserRECONFIGURE, SnowflakeParserRECORD_DELIMITER, SnowflakeParserRECOVERY, SnowflakeParserRECURSIVE, SnowflakeParserRECURSIVE_TRIGGERS, SnowflakeParserREFERENCES, SnowflakeParserREFERENCE_USAGE, SnowflakeParserREFRESH, SnowflakeParserREFRESH_ON_CREATE, SnowflakeParserREGION, SnowflakeParserREGIONS, SnowflakeParserREGION_GROUP, SnowflakeParserRELATIVE, SnowflakeParserRELY, SnowflakeParserREMOTE, SnowflakeParserREMOTE_PROC_TRANSACTIONS, SnowflakeParserREMOTE_SERVICE_NAME, SnowflakeParserREMOVE, SnowflakeParserRENAME, SnowflakeParserREPEATABLE, SnowflakeParserREPLACE, SnowflakeParserREPLACE_INVALID_CHARACTERS, SnowflakeParserREPLICA, SnowflakeParserREPLICATION, SnowflakeParserREPLICATION_SCHEDULE, SnowflakeParserREQUEST_TRANSLATOR, SnowflakeParserREQUIRED, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, SnowflakeParserRESET, SnowflakeParserRESOURCE, SnowflakeParserRESOURCES, SnowflakeParserRESOURCE_MONITOR, SnowflakeParserRESPONSE_TRANSLATOR, SnowflakeParserRESTART, SnowflakeParserRESTORE, SnowflakeParserRESTRICT, SnowflakeParserRESTRICTIONS, SnowflakeParserRESULT, SnowflakeParserRESUME, SnowflakeParserRETAINDAYS, SnowflakeParserRETURN, SnowflakeParserRETURNS, SnowflakeParserRETURN_ALL_ERRORS, SnowflakeParserRETURN_ERRORS, SnowflakeParserRETURN_FAILED_ONLY, SnowflakeParserRETURN_N_ROWS, SnowflakeParserRETURN_ROWS, SnowflakeParserREVERSE, SnowflakeParserREVERT, SnowflakeParserREWIND, SnowflakeParserROLE, SnowflakeParserROLES, SnowflakeParserROLLBACK, SnowflakeParserROLLUP, SnowflakeParserROOT, SnowflakeParserROWCOUNT, SnowflakeParserROWGUID, SnowflakeParserROWLOCK, SnowflakeParserROWS_PER_RESULTSET, SnowflakeParserROW_NUMBER, SnowflakeParserRSA_PUBLIC_KEY, SnowflakeParserRTRIM, SnowflakeParserRUN_AS_ROLE, SnowflakeParserSAFE, SnowflakeParserSAFETY, SnowflakeParserSAML_IDENTITY_PROVIDER, SnowflakeParserSAVE_OLD_URL, SnowflakeParserSCALING_POLICY, SnowflakeParserSCHEDULE, SnowflakeParserSCHEDULER, SnowflakeParserSCHEMA, SnowflakeParserSCHEMAS, SnowflakeParserSCHEME, SnowflakeParserSCIM, SnowflakeParserSCIM_CLIENT, SnowflakeParserSCRIPT, SnowflakeParserSEARCH, SnowflakeParserSECONDARY, SnowflakeParserSECONDARY_ONLY, SnowflakeParserSECONDARY_ROLE, SnowflakeParserSECONDS, SnowflakeParserSECRET, SnowflakeParserSECURE, SnowflakeParserSECURITY, SnowflakeParserSECURITYADMIN, SnowflakeParserSEED, SnowflakeParserSELF, SnowflakeParserSEQUENCE, SnowflakeParserSEQUENCES, SnowflakeParserSERVER, SnowflakeParserSERVICE, SnowflakeParserSESSION, SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, SnowflakeParserSESSION_POLICY, SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, SnowflakeParserSETS, SnowflakeParserSETUSER, SnowflakeParserSHARE, SnowflakeParserSHARED, SnowflakeParserSHARES, SnowflakeParserSHARE_RESTRICTIONS, SnowflakeParserSHOW, SnowflakeParserSHOWPLAN, SnowflakeParserSHOWPLAN_ALL, SnowflakeParserSHOWPLAN_TEXT, SnowflakeParserSHOWPLAN_XML, SnowflakeParserSHOW_INITIAL_ROWS, SnowflakeParserSIGNATURE, SnowflakeParserSIMPLE, SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, SnowflakeParserSINGLE_USER, SnowflakeParserSIZE, SnowflakeParserSIZE_LIMIT, SnowflakeParserSKIP_, SnowflakeParserSKIP_BLANK_LINES, SnowflakeParserSKIP_BYTE_ORDER_MARK, SnowflakeParserSKIP_FILE, SnowflakeParserSKIP_FILE_N, SnowflakeParserSKIP_HEADER, SnowflakeParserSMALL, SnowflakeParserSNAPPY, SnowflakeParserSNAPPY_COMPRESSION, SnowflakeParserSOUNDEX, SnowflakeParserSOURCE, SnowflakeParserSOURCE_COMPRESSION, SnowflakeParserSPACE_KEYWORD, SnowflakeParserSPARSE, SnowflakeParserSPECIFICATION, SnowflakeParserSPLIT, SnowflakeParserSPLIT_PART, SnowflakeParserSQL, SnowflakeParserSSO_LOGIN_PAGE, SnowflakeParserSTAGE, SnowflakeParserSTAGES, SnowflakeParserSTAGE_COPY_OPTIONS, SnowflakeParserSTAGE_FILE_FORMAT, SnowflakeParserSTANDARD, SnowflakeParserSTANDBY, SnowflakeParserSTARTED, SnowflakeParserSTARTS, SnowflakeParserSTART_DATE, SnowflakeParserSTART_TIMESTAMP, SnowflakeParserSTATE, SnowflakeParserSTATEMENT, SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, SnowflakeParserSTATIC, SnowflakeParserSTATISTICS, SnowflakeParserSTATS, SnowflakeParserSTATS_DATE, SnowflakeParserSTATS_STREAM, SnowflakeParserSTATUS, SnowflakeParserSTATUSONLY, SnowflakeParserSTDEV, SnowflakeParserSTDEVP, SnowflakeParserSTOP, SnowflakeParserSTOPLIST, SnowflakeParserSTOPPED, SnowflakeParserSTORAGE, SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, SnowflakeParserSTORAGE_AWS_OBJECT_ACL, SnowflakeParserSTORAGE_AWS_ROLE_ARN, SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, SnowflakeParserSTORAGE_INTEGRATION, SnowflakeParserSTORAGE_PROVIDER, SnowflakeParserSTR, SnowflakeParserSTREAM, SnowflakeParserSTREAMS, SnowflakeParserSTRICT, SnowflakeParserSTRICT_JSON_OUTPUT, SnowflakeParserSTRING_AGG, SnowflakeParserSTRING_ESCAPE, SnowflakeParserSTRIP_NULL_VALUES, SnowflakeParserSTRIP_OUTER_ARRAY, SnowflakeParserSTRIP_OUTER_ELEMENT, SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING, SnowflakeParserSUM, SnowflakeParserSUPPORTED, SnowflakeParserSUSPEND, SnowflakeParserSUSPENDED, SnowflakeParserSUSPEND_IMMEDIATE, SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, SnowflakeParserSWAP, SnowflakeParserSWITCH, SnowflakeParserSYNC_PASSWORD, SnowflakeParserSYSADMIN, SnowflakeParserSYSTEM, SnowflakeParserSYSTEM_USER, SnowflakeParserTABLEAU_DESKTOP, SnowflakeParserTABLEAU_SERVER, SnowflakeParserTABLES, SnowflakeParserTABLE_FORMAT, SnowflakeParserTABULAR, SnowflakeParserTAG, SnowflakeParserTAGS, SnowflakeParserTARGET, SnowflakeParserTARGET_LAG, SnowflakeParserTASK, SnowflakeParserTASKS, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserTERSE, SnowflakeParserTEXTSIZE, SnowflakeParserTIES, SnowflakeParserTIME, SnowflakeParserTIMEADD, SnowflakeParserTIMEDIFF, SnowflakeParserTIMEOUT, SnowflakeParserTIMER, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_FORMAT, SnowflakeParserTIMESTAMP_INPUT_FORMAT, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_TYPE_MAPPING, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMPADD, SnowflakeParserTIMESTAMPDIFF, SnowflakeParserTIMEZONE, SnowflakeParserTIME_FORMAT, SnowflakeParserTIME_INPUT_FORMAT, SnowflakeParserTIME_OUTPUT_FORMAT, SnowflakeParserTO_BOOLEAN, SnowflakeParserTO_DATE, SnowflakeParserTOP, SnowflakeParserTORN_PAGE_DETECTION, SnowflakeParserTRACKING, SnowflakeParserTRACK_CAUSALITY, SnowflakeParserTRAN, SnowflakeParserTRANSACTION, SnowflakeParserTRANSACTIONS, SnowflakeParserTRANSACTION_ABORT_ON_ERROR, SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, SnowflakeParserTRANSACTION_ID, SnowflakeParserTRANSFORM_NOISE_WORDS, SnowflakeParserTRANSIENT, SnowflakeParserTRANSLATE, SnowflakeParserTRIGGERS, SnowflakeParserTRIM, SnowflakeParserTRIM_SPACE, SnowflakeParserTRIPLE_DES, SnowflakeParserTRUNCATE, SnowflakeParserTRUNCATECOLUMNS, SnowflakeParserTRUSTWORTHY, SnowflakeParserTRY, SnowflakeParserTSEQUAL, SnowflakeParserTSQL, SnowflakeParserTWO_DIGIT_CENTURY_START, SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, SnowflakeParserTYPE, SnowflakeParserTYPEPROPERTY, SnowflakeParserTYPE_ID, SnowflakeParserTYPE_NAME, SnowflakeParserTYPE_WARNING, SnowflakeParserUN, SnowflakeParserUNBOUNDED, SnowflakeParserUNCHECKED, SnowflakeParserUNCOMMITTED, SnowflakeParserUNDROP, SnowflakeParserUNICODE, SnowflakeParserUNKNOWN, SnowflakeParserUNLIMITED, SnowflakeParserUNLOCK, SnowflakeParserUNMASK, SnowflakeParserUNMATCHED, SnowflakeParserUNPIVOT, SnowflakeParserUNSAFE, SnowflakeParserUNSET, SnowflakeParserUNSUPPORTED_DDL_ACTION, SnowflakeParserUOW, SnowflakeParserUPDLOCK, SnowflakeParserUPPER, SnowflakeParserURL, SnowflakeParserUSAGE, SnowflakeParserUSE, SnowflakeParserUSED, SnowflakeParserUSER, SnowflakeParserUSERADMIN, SnowflakeParserUSERS, SnowflakeParserUSER_SPECIFIED, SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, SnowflakeParserUSER_TASK_TIMEOUT_MS, SnowflakeParserUSE_ANY_ROLE, SnowflakeParserUSE_CACHED_RESULT, SnowflakeParserVALIDATE, SnowflakeParserVALIDATION, SnowflakeParserVALIDATION_MODE, SnowflakeParserVALID_XML, SnowflakeParserVALUE, SnowflakeParserVAR, SnowflakeParserVARIABLES, SnowflakeParserVARP, SnowflakeParserVARYING, SnowflakeParserVERSION, SnowflakeParserVIEWS, SnowflakeParserVIEW_METADATA, SnowflakeParserVISIBILITY, SnowflakeParserVOLATILE, SnowflakeParserWAIT, SnowflakeParserWAREHOUSE, SnowflakeParserWAREHOUSES, SnowflakeParserWAREHOUSE_SIZE, SnowflakeParserWEEKLY, SnowflakeParserWEEK_OF_YEAR_POLICY, SnowflakeParserWEEK_START, SnowflakeParserWELL_FORMED_XML, SnowflakeParserWITHIN, SnowflakeParserWITHOUT, SnowflakeParserWITHOUT_ARRAY_WRAPPER, SnowflakeParserWORK, SnowflakeParserWORKLOAD, SnowflakeParserWRITE, SnowflakeParserXLARGE, SnowflakeParserXLOCK, SnowflakeParserXML, SnowflakeParserXML_Q, SnowflakeParserXSMALL, SnowflakeParserXXLARGE, SnowflakeParserXXXLARGE, SnowflakeParserYEARLY, SnowflakeParserZSTD, SnowflakeParserARRAY, SnowflakeParserARRAY_Q, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserCHAR_VARYING, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNCHAR_VARYING, SnowflakeParserNUMERIC, SnowflakeParserNVARCHAR, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT, SnowflakeParserLISTAGG, SnowflakeParserDUMMY, SnowflakeParserDOUBLE_QUOTE_ID, SnowflakeParserDOUBLE_QUOTE_BLANK, SnowflakeParserID, SnowflakeParserID2, SnowflakeParserRR_BRACKET, SnowflakeParserSEMI: + p.SetState(9927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSCHEMA { + { + p.SetState(9926) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9930) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1242, p.GetParserRuleContext()) == 1 { + { + p.SetState(9929) + p.Schema_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(9937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTARTS { + { + p.SetState(9936) + p.Starts_with() + } + + } + p.SetState(9940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIMIT { + { + p.SetState(9939) + p.Limit_rows() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_external_tablesContext is an interface to support dynamic dispatch. +type IShow_external_tablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + TABLES() antlr.TerminalNode + TERSE() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + Starts_with() IStarts_withContext + Limit_rows() ILimit_rowsContext + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsShow_external_tablesContext differentiates from other interfaces. + IsShow_external_tablesContext() +} + +type Show_external_tablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_external_tablesContext() *Show_external_tablesContext { + var p = new(Show_external_tablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_external_tables + return p +} + +func InitEmptyShow_external_tablesContext(p *Show_external_tablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_external_tables +} + +func (*Show_external_tablesContext) IsShow_external_tablesContext() {} + +func NewShow_external_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_external_tablesContext { + var p = new(Show_external_tablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_external_tables + + return p +} + +func (s *Show_external_tablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_external_tablesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_external_tablesContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Show_external_tablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLES, 0) +} + +func (s *Show_external_tablesContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Show_external_tablesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_external_tablesContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_external_tablesContext) Starts_with() IStarts_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStarts_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStarts_withContext) +} + +func (s *Show_external_tablesContext) Limit_rows() ILimit_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_rowsContext) +} + +func (s *Show_external_tablesContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_external_tablesContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_external_tablesContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_external_tablesContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_external_tablesContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_external_tablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_external_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_external_tablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_external_tables(s) + } +} + +func (s *Show_external_tablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_external_tables(s) + } +} + +func (s *Show_external_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_external_tables(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_external_tables() (localctx IShow_external_tablesContext) { + localctx = NewShow_external_tablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 738, SnowflakeParserRULE_show_external_tables) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9942) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTERSE { + { + p.SetState(9943) + p.Match(SnowflakeParserTERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9946) + p.Match(SnowflakeParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9947) + p.Match(SnowflakeParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(9948) + p.Like_pattern() + } + + } + p.SetState(9965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(9951) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT: + { + p.SetState(9952) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(9953) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9955) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1249, p.GetParserRuleContext()) == 1 { + { + p.SetState(9954) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserEOF, SnowflakeParserAAD_PROVISIONER_Q, SnowflakeParserABORT, SnowflakeParserABORT_AFTER_WAIT, SnowflakeParserABORT_DETACHED_QUERY, SnowflakeParserABORT_STATEMENT, SnowflakeParserABSENT, SnowflakeParserABSOLUTE, SnowflakeParserACCESS, SnowflakeParserACCOUNTADMIN, SnowflakeParserACCOUNTS, SnowflakeParserACTION, SnowflakeParserACTIVE, SnowflakeParserADD, SnowflakeParserADMINISTER, SnowflakeParserADMIN_NAME, SnowflakeParserADMIN_PASSWORD, SnowflakeParserAES, SnowflakeParserAFTER, SnowflakeParserAGGREGATE, SnowflakeParserALERT, SnowflakeParserALERTS, SnowflakeParserALLOWED, SnowflakeParserALLOWED_ACCOUNTS, SnowflakeParserALLOWED_DATABASES, SnowflakeParserALLOWED_INTEGRATION_TYPES, SnowflakeParserALLOWED_IP_LIST, SnowflakeParserALLOWED_SHARES, SnowflakeParserALLOWED_VALUES, SnowflakeParserALLOW_CLIENT_MFA_CACHING, SnowflakeParserALLOW_CONNECTIONS, SnowflakeParserALLOW_DUPLICATE, SnowflakeParserALLOW_ID_TOKEN, SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, SnowflakeParserALLOW_OVERLAPPING_EXECUTION, SnowflakeParserALLOW_SINGLE_EVENT_LOSS, SnowflakeParserALWAYS, SnowflakeParserANONYMOUS, SnowflakeParserANSI_DEFAULTS, SnowflakeParserAPI, SnowflakeParserAPI_ALLOWED_PREFIXES, SnowflakeParserAPI_AWS_ROLE_ARN, SnowflakeParserAPI_BLOCKED_PREFIXES, SnowflakeParserAPI_INTEGRATION, SnowflakeParserAPI_KEY, SnowflakeParserAPI_PROVIDER, SnowflakeParserAPPEND, SnowflakeParserAPPEND_ONLY, SnowflakeParserAPPLICATION, SnowflakeParserAPPLY, SnowflakeParserAPP_NAME, SnowflakeParserASC, SnowflakeParserATTACH, SnowflakeParserAT_KEYWORD, SnowflakeParserAUTHORIZATION, SnowflakeParserAUTHORIZATIONS, SnowflakeParserAUTO, SnowflakeParserAUTO_Q, SnowflakeParserAUTOCOMMIT, SnowflakeParserAUTOCOMMIT_API_SUPPORTED, SnowflakeParserAUTOINCREMENT, SnowflakeParserAUTO_COMPRESS, SnowflakeParserAUTO_DETECT, SnowflakeParserAUTO_INGEST, SnowflakeParserAUTO_REFRESH, SnowflakeParserAUTO_RESUME, SnowflakeParserAUTO_SUSPEND, SnowflakeParserAVG, SnowflakeParserAVRO, SnowflakeParserAVRO_Q, SnowflakeParserAWS_KEY_ID, SnowflakeParserAWS_ROLE, SnowflakeParserAWS_SECRET_KEY, SnowflakeParserAWS_SNS, SnowflakeParserAWS_SNS_ROLE_ARN, SnowflakeParserAWS_SNS_TOPIC, SnowflakeParserAWS_SNS_TOPIC_ARN, SnowflakeParserAWS_TOKEN, SnowflakeParserAZURE, SnowflakeParserAZURE_AD_APPLICATION_ID, SnowflakeParserAZURE_EVENT_GRID, SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, SnowflakeParserAZURE_Q, SnowflakeParserAZURE_SAS_TOKEN, SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, SnowflakeParserAZURE_TENANT_ID, SnowflakeParserBEFORE, SnowflakeParserBEGIN, SnowflakeParserBERNOULLI, SnowflakeParserBINARY_AS_TEXT, SnowflakeParserBINARY_CHECKSUM, SnowflakeParserBINARY_FORMAT, SnowflakeParserBINARY_INPUT_FORMAT, SnowflakeParserBINARY_OUTPUT_FORMAT, SnowflakeParserBINDING, SnowflakeParserBLOCK, SnowflakeParserBLOCKED_IP_LIST, SnowflakeParserBLOCKED_ROLES_LIST, SnowflakeParserBODY, SnowflakeParserBOTH_Q, SnowflakeParserBROTLI, SnowflakeParserBUSINESS_CRITICAL, SnowflakeParserCACHE, SnowflakeParserCALL, SnowflakeParserCALLED, SnowflakeParserCALLER, SnowflakeParserCASCADE, SnowflakeParserCASE_INSENSITIVE, SnowflakeParserCASE_SENSITIVE, SnowflakeParserCATCH, SnowflakeParserCERTIFICATE, SnowflakeParserCHANGE, SnowflakeParserCHANGES, SnowflakeParserCHANGETABLE, SnowflakeParserCHANGE_RETENTION, SnowflakeParserCHANGE_TRACKING, SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserCHARINDEX, SnowflakeParserCHECKSUM, SnowflakeParserCHECKSUM_AGG, SnowflakeParserCHECK_EXPIRATION, SnowflakeParserCHECK_POLICY, SnowflakeParserCLASSIFIER_FUNCTION, SnowflakeParserCLEANUP, SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, SnowflakeParserCLIENT_MEMORY_LIMIT, SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, SnowflakeParserCLIENT_PREFETCH_THREADS, SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, SnowflakeParserCLONE, SnowflakeParserCLOSE, SnowflakeParserCLUSTER, SnowflakeParserCLUSTERED, SnowflakeParserCLUSTERING, SnowflakeParserCOALESCE, SnowflakeParserCOLLATE, SnowflakeParserCOLLECTION, SnowflakeParserCOLUMNS, SnowflakeParserCOL_LENGTH, SnowflakeParserCOL_NAME, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOMMITTED, SnowflakeParserCOMPRESS, SnowflakeParserCOMPRESSION, SnowflakeParserCONCAT, SnowflakeParserCONCAT_NULL_YIELDS_NULL, SnowflakeParserCONCAT_WS, SnowflakeParserCONDITION, SnowflakeParserCONFIGURATION, SnowflakeParserCONNECTIONS, SnowflakeParserCONTAINMENT, SnowflakeParserCONTAINS, SnowflakeParserCONTENT, SnowflakeParserCONTEXT, SnowflakeParserCONTEXT_HEADERS, SnowflakeParserCONTEXT_INFO, SnowflakeParserCONTINUE, SnowflakeParserCONTROL, SnowflakeParserCONVERSATION, SnowflakeParserCOOKIE, SnowflakeParserCOPY, SnowflakeParserCOPY_ONLY, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserCOUNT, SnowflakeParserCOUNT_BIG, SnowflakeParserCREDENTIALS, SnowflakeParserCREDIT_QUOTA, SnowflakeParserCSV, SnowflakeParserCSV_Q, SnowflakeParserCUBE, SnowflakeParserCUME_DIST, SnowflakeParserCURRENT_DATE, SnowflakeParserCURRENT_TIMESTAMP, SnowflakeParserCURSOR, SnowflakeParserCUSTOM, SnowflakeParserDAILY, SnowflakeParserDATA, SnowflakeParserDATABASES, SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, SnowflakeParserDATEADD, SnowflakeParserDATEDIFF, SnowflakeParserDATENAME, SnowflakeParserDATEPART, SnowflakeParserDATE_FORMAT, SnowflakeParserDATE_INPUT_FORMAT, SnowflakeParserDATE_OUTPUT_FORMAT, SnowflakeParserDATE_PART, SnowflakeParserDAYS, SnowflakeParserDAYS_TO_EXPIRY, SnowflakeParserDECLARE, SnowflakeParserDEFAULT, SnowflakeParserDEFAULT_DDL_COLLATION_, SnowflakeParserDEFAULT_NAMESPACE, SnowflakeParserDEFAULT_ROLE, SnowflakeParserDEFAULT_WAREHOUSE, SnowflakeParserDEFERRABLE, SnowflakeParserDEFERRED, SnowflakeParserDEFINE, SnowflakeParserDEFINITION, SnowflakeParserDEFLATE, SnowflakeParserDELEGATED, SnowflakeParserDELTA, SnowflakeParserDENSE_RANK, SnowflakeParserDESC, SnowflakeParserDESCRIBE, SnowflakeParserDIRECTION, SnowflakeParserDIRECTORY, SnowflakeParserDISABLE, SnowflakeParserDISABLED, SnowflakeParserDISABLE_AUTO_CONVERT, SnowflakeParserDISABLE_SNOWFLAKE_DATA, SnowflakeParserDISK, SnowflakeParserDISPLAY_NAME, SnowflakeParserDO, SnowflakeParserDOWNSTREAM, SnowflakeParserDOUBLE, SnowflakeParserDYNAMIC, SnowflakeParserECONOMY, SnowflakeParserEDITION, SnowflakeParserEMAIL, SnowflakeParserEMPTY_, SnowflakeParserEMPTY_FIELD_AS_NULL, SnowflakeParserENABLE, SnowflakeParserENABLED, SnowflakeParserENABLE_FOR_PRIVILEGE, SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, SnowflakeParserENABLE_OCTAL, SnowflakeParserENABLE_QUERY_ACCELERATION, SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, SnowflakeParserENCODING, SnowflakeParserENCRYPTION, SnowflakeParserEND, SnowflakeParserENDPOINT, SnowflakeParserEND_TIMESTAMP, SnowflakeParserENFORCED, SnowflakeParserENFORCE_LENGTH, SnowflakeParserENFORCE_SESSION_POLICY, SnowflakeParserENTERPRISE, SnowflakeParserEQUALITY, SnowflakeParserERROR_INTEGRATION, SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, SnowflakeParserESCAPE, SnowflakeParserESCAPE_UNENCLOSED_FIELD, SnowflakeParserEXCEPT, SnowflakeParserEXCHANGE, SnowflakeParserEXECUTE, SnowflakeParserEXECUTION, SnowflakeParserEXIST, SnowflakeParserEXIT, SnowflakeParserEXPAND, SnowflakeParserEXPIRY_DATE, SnowflakeParserEXPLAIN, SnowflakeParserEXPLICIT, SnowflakeParserEXTERNAL, SnowflakeParserEXTERNAL_OAUTH, SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ISSUER, SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, SnowflakeParserEXTERNAL_OAUTH_TYPE, SnowflakeParserEXTERNAL_STAGE, SnowflakeParserFAILOVER, SnowflakeParserFAILOVER_MODE, SnowflakeParserFAIL_OPERATION, SnowflakeParserFETCH, SnowflakeParserFIELD_DELIMITER, SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, SnowflakeParserFILE, SnowflakeParserFILES, SnowflakeParserFILE_EXTENSION, SnowflakeParserFILE_FORMAT, SnowflakeParserFILTER, SnowflakeParserFIRST, SnowflakeParserFIRST_NAME, SnowflakeParserFLATTEN, SnowflakeParserFORCE, SnowflakeParserFOREIGN, SnowflakeParserFORMAT, SnowflakeParserFORMATS, SnowflakeParserFORMAT_NAME, SnowflakeParserFREQUENCY, SnowflakeParserFUNCTION, SnowflakeParserFUNCTIONS, SnowflakeParserFUTURE, SnowflakeParserGCP_PUBSUB, SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, SnowflakeParserGCP_PUBSUB_TOPIC_NAME, SnowflakeParserGCS, SnowflakeParserGENERIC_Q, SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, SnowflakeParserGEO, SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, SnowflakeParserGEOMETRY_OUTPUT_FORMAT, SnowflakeParserGET, SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, SnowflakeParserGLOBAL, SnowflakeParserGOOGLE_AUDIENCE, SnowflakeParserGOTO, SnowflakeParserGRANTS, SnowflakeParserGROUPING, SnowflakeParserGROUPING_ID, SnowflakeParserGROUPS, SnowflakeParserGZIP, SnowflakeParserHEADER, SnowflakeParserHEADERS, SnowflakeParserHEX, SnowflakeParserHIERARCHYID, SnowflakeParserHIGH, SnowflakeParserHISTORY, SnowflakeParserHOURS, SnowflakeParserIDENTITY, SnowflakeParserIF, SnowflakeParserIFF, SnowflakeParserIFNULL, SnowflakeParserIGNORE, SnowflakeParserIGNORE_CONSTRAINTS, SnowflakeParserIGNORE_DUP_KEY, SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, SnowflakeParserIGNORE_TRIGGERS, SnowflakeParserIMMEDIATE, SnowflakeParserIMMEDIATELY, SnowflakeParserIMMUTABLE, SnowflakeParserIMPLICIT, SnowflakeParserIMPORT, SnowflakeParserIMPORTED, SnowflakeParserINDEX, SnowflakeParserINFORMATION, SnowflakeParserINIT, SnowflakeParserINITIALLY, SnowflakeParserINITIALLY_SUSPENDED, SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, SnowflakeParserINPUT, SnowflakeParserINSERT_ONLY, SnowflakeParserINSTEAD, SnowflakeParserINT, SnowflakeParserINTEGRATION, SnowflakeParserINTEGRATIONS, SnowflakeParserISNULL, SnowflakeParserISNUMERIC, SnowflakeParserISOLATION, SnowflakeParserJAVASCRIPT, SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, SnowflakeParserJDBC_USE_SESSION_TIMEZONE, SnowflakeParserJSON, SnowflakeParserJSON_Q, SnowflakeParserJSON_INDENT, SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, SnowflakeParserKB, SnowflakeParserKEEP, SnowflakeParserKEY, SnowflakeParserKEYS, SnowflakeParserKEYSET, SnowflakeParserKMS_KEY_ID, SnowflakeParserLAG, SnowflakeParserLANGUAGE, SnowflakeParserLARGE, SnowflakeParserLAST, SnowflakeParserLAST_NAME, SnowflakeParserLAST_QUERY_ID, SnowflakeParserLAST_VALUE, SnowflakeParserLEAD, SnowflakeParserLEN, SnowflakeParserLENGTH, SnowflakeParserLEVEL, SnowflakeParserLIMIT, SnowflakeParserLINENO, SnowflakeParserLIST, SnowflakeParserLISTENER_IP, SnowflakeParserLISTENER_PORT, SnowflakeParserLISTING, SnowflakeParserLOAD, SnowflakeParserLOCAL, SnowflakeParserLOCAL_SERVICE_NAME, SnowflakeParserLOCATION, SnowflakeParserLOCKS, SnowflakeParserLOCK_TIMEOUT, SnowflakeParserLOG, SnowflakeParserLOGIN, SnowflakeParserLOGIN_NAME, SnowflakeParserLOOKER, SnowflakeParserLOW, SnowflakeParserLOWER, SnowflakeParserLTRIM, SnowflakeParserLZO, SnowflakeParserMANAGE, SnowflakeParserMANAGED, SnowflakeParserMASK, SnowflakeParserMASKED, SnowflakeParserMASKING, SnowflakeParserMASTER, SnowflakeParserMASTER_KEY, SnowflakeParserMATCH, SnowflakeParserMATCHED, SnowflakeParserMATCHES, SnowflakeParserMATCH_BY_COLUMN_NAME, SnowflakeParserMATCH_RECOGNIZE, SnowflakeParserMATERIALIZED, SnowflakeParserMAX_BATCH_ROWS, SnowflakeParserMAX_CLUSTER_COUNT, SnowflakeParserMAX_CONCURRENCY_LEVEL, SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, SnowflakeParserMAX_SIZE, SnowflakeParserMEASURES, SnowflakeParserMEDIUM, SnowflakeParserMEMOIZABLE, SnowflakeParserMERGE, SnowflakeParserMIDDLE_NAME, SnowflakeParserMIN, SnowflakeParserMINS_TO_BYPASS_MFA, SnowflakeParserMINS_TO_UNLOCK, SnowflakeParserMINUS_, SnowflakeParserMINUTES, SnowflakeParserMIN_CLUSTER_COUNT, SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, SnowflakeParserMODE, SnowflakeParserMODIFIED_AFTER, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserMONITORS, SnowflakeParserMONTHLY, SnowflakeParserMOVE, SnowflakeParserMULTI_STATEMENT_COUNT, SnowflakeParserMULTI_USER, SnowflakeParserMUST_CHANGE, SnowflakeParserMUST_CHANGE_PASSWORD, SnowflakeParserNAME, SnowflakeParserNCHAR, SnowflakeParserNESTED_TRIGGERS, SnowflakeParserNETWORK, SnowflakeParserNETWORK_POLICY, SnowflakeParserNEVER, SnowflakeParserNEWID, SnowflakeParserNEWNAME, SnowflakeParserNEWSEQUENTIALID, SnowflakeParserNEW_ACCOUNT, SnowflakeParserNEW_BROKER, SnowflakeParserNEW_PASSWORD, SnowflakeParserNEXT, SnowflakeParserNEXTVAL, SnowflakeParserNO, SnowflakeParserNONE, SnowflakeParserNONE_Q, SnowflakeParserNORELY, SnowflakeParserNOTIFICATION, SnowflakeParserNOTIFICATIONS, SnowflakeParserNOTIFICATION_INTEGRATION, SnowflakeParserNOTIFICATION_PROVIDER, SnowflakeParserNOTIFY, SnowflakeParserNOTIFY_USERS, SnowflakeParserNOVALIDATE, SnowflakeParserNTILE, SnowflakeParserNULLIF, SnowflakeParserNULLS, SnowflakeParserNULL_, SnowflakeParserNULL_IF, SnowflakeParserNUMANODE, SnowflakeParserNUMBER, SnowflakeParserNUMERIC_ROUNDABORT, SnowflakeParserNVL, SnowflakeParserOAUTH, SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, SnowflakeParserOAUTH_CLIENT, SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, SnowflakeParserOAUTH_ENFORCE_PKCE, SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, SnowflakeParserOAUTH_REDIRECT_URI, SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, SnowflakeParserOAUTH_USE_SECONDARY_ROLES, SnowflakeParserOBJECT, SnowflakeParserOBJECT_Q, SnowflakeParserOBJECTS, SnowflakeParserOBJECT_TYPES, SnowflakeParserOFF, SnowflakeParserOFFSET, SnowflakeParserOFFSETS, SnowflakeParserOKTA, SnowflakeParserOKTA_PROVISIONER_Q, SnowflakeParserOKTA_Q, SnowflakeParserOLD, SnowflakeParserOLD_ACCOUNT, SnowflakeParserOLD_PASSWORD, SnowflakeParserOMIT, SnowflakeParserONE, SnowflakeParserONLINE, SnowflakeParserONLY, SnowflakeParserON_ERROR, SnowflakeParserON_FAILURE, SnowflakeParserOPEN, SnowflakeParserOPERATE, SnowflakeParserOPERATIONS, SnowflakeParserOPTIMIZATION, SnowflakeParserOPTION, SnowflakeParserORC, SnowflakeParserORC_Q, SnowflakeParserORGADMIN, SnowflakeParserOUTBOUND, SnowflakeParserOUTER, SnowflakeParserOVER, SnowflakeParserOVERRIDE, SnowflakeParserOVERWRITE, SnowflakeParserOWNER, SnowflakeParserOWNERSHIP, SnowflakeParserPAGE, SnowflakeParserPARALLEL, SnowflakeParserPARAMETERS, SnowflakeParserPARAM_NODE, SnowflakeParserPARQUET, SnowflakeParserPARQUET_Q, SnowflakeParserPARTIAL, SnowflakeParserPARTITION, SnowflakeParserPARTITIONS, SnowflakeParserPARTITION_TYPE, SnowflakeParserPASSWORD, SnowflakeParserPAST, SnowflakeParserPATH_, SnowflakeParserPATTERN, SnowflakeParserPER, SnowflakeParserPERCENT, SnowflakeParserPERCENTILE_CONT, SnowflakeParserPERCENTILE_DISC, SnowflakeParserPERCENT_RANK, SnowflakeParserPERIODIC_DATA_REKEYING, SnowflakeParserPERMISSION_SET, SnowflakeParserPERSISTED, SnowflakeParserPERSIST_SAMPLE_PERCENT, SnowflakeParserPING_FEDERATE, SnowflakeParserPIPE, SnowflakeParserPIPES, SnowflakeParserPIPE_EXECUTION_PAUSED, SnowflakeParserPIVOT, SnowflakeParserPLAN, SnowflakeParserPLATFORM, SnowflakeParserPOLICIES, SnowflakeParserPOLICY, SnowflakeParserPOOL, SnowflakeParserPORT, SnowflakeParserPRECEDING, SnowflakeParserPRECISION, SnowflakeParserPREDICATE, SnowflakeParserPREFIX, SnowflakeParserPRESERVE_SPACE, SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, SnowflakeParserPRIMARY, SnowflakeParserPRIMARY_ROLE, SnowflakeParserPRIOR, SnowflakeParserPRIORITY, SnowflakeParserPRIORITY_LEVEL, SnowflakeParserPRIVATE, SnowflakeParserPRIVATE_KEY, SnowflakeParserPRIVILEGES, SnowflakeParserPROC, SnowflakeParserPROCEDURE, SnowflakeParserPROCEDURES, SnowflakeParserPROCEDURE_NAME, SnowflakeParserPROCESS, SnowflakeParserPROFILE, SnowflakeParserPROPERTY, SnowflakeParserPROVIDER, SnowflakeParserPROVIDER_KEY_NAME, SnowflakeParserPUBLIC, SnowflakeParserPURGE, SnowflakeParserPUT, SnowflakeParserPYTHON, SnowflakeParserQUERIES, SnowflakeParserQUERY, SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, SnowflakeParserQUERY_TAG, SnowflakeParserQUEUE, SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, SnowflakeParserRANGE, SnowflakeParserRANK, SnowflakeParserRAW_DEFLATE, SnowflakeParserREAD, SnowflakeParserREADER, SnowflakeParserREADONLY, SnowflakeParserREADPAST, SnowflakeParserREADTEXT, SnowflakeParserREADWRITE, SnowflakeParserREAD_COMMITTED_SNAPSHOT, SnowflakeParserREAD_ONLY, SnowflakeParserREAD_ONLY_ROUTING_LIST, SnowflakeParserREAD_WRITE, SnowflakeParserREBUILD, SnowflakeParserRECEIVE, SnowflakeParserRECLUSTER, SnowflakeParserRECOMPILE, SnowflakeParserRECONFIGURE, SnowflakeParserRECORD_DELIMITER, SnowflakeParserRECOVERY, SnowflakeParserRECURSIVE, SnowflakeParserRECURSIVE_TRIGGERS, SnowflakeParserREFERENCES, SnowflakeParserREFERENCE_USAGE, SnowflakeParserREFRESH, SnowflakeParserREFRESH_ON_CREATE, SnowflakeParserREGION, SnowflakeParserREGIONS, SnowflakeParserREGION_GROUP, SnowflakeParserRELATIVE, SnowflakeParserRELY, SnowflakeParserREMOTE, SnowflakeParserREMOTE_PROC_TRANSACTIONS, SnowflakeParserREMOTE_SERVICE_NAME, SnowflakeParserREMOVE, SnowflakeParserRENAME, SnowflakeParserREPEATABLE, SnowflakeParserREPLACE, SnowflakeParserREPLACE_INVALID_CHARACTERS, SnowflakeParserREPLICA, SnowflakeParserREPLICATION, SnowflakeParserREPLICATION_SCHEDULE, SnowflakeParserREQUEST_TRANSLATOR, SnowflakeParserREQUIRED, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, SnowflakeParserRESET, SnowflakeParserRESOURCE, SnowflakeParserRESOURCES, SnowflakeParserRESOURCE_MONITOR, SnowflakeParserRESPONSE_TRANSLATOR, SnowflakeParserRESTART, SnowflakeParserRESTORE, SnowflakeParserRESTRICT, SnowflakeParserRESTRICTIONS, SnowflakeParserRESULT, SnowflakeParserRESUME, SnowflakeParserRETAINDAYS, SnowflakeParserRETURN, SnowflakeParserRETURNS, SnowflakeParserRETURN_ALL_ERRORS, SnowflakeParserRETURN_ERRORS, SnowflakeParserRETURN_FAILED_ONLY, SnowflakeParserRETURN_N_ROWS, SnowflakeParserRETURN_ROWS, SnowflakeParserREVERSE, SnowflakeParserREVERT, SnowflakeParserREWIND, SnowflakeParserROLE, SnowflakeParserROLES, SnowflakeParserROLLBACK, SnowflakeParserROLLUP, SnowflakeParserROOT, SnowflakeParserROWCOUNT, SnowflakeParserROWGUID, SnowflakeParserROWLOCK, SnowflakeParserROWS_PER_RESULTSET, SnowflakeParserROW_NUMBER, SnowflakeParserRSA_PUBLIC_KEY, SnowflakeParserRTRIM, SnowflakeParserRUN_AS_ROLE, SnowflakeParserSAFE, SnowflakeParserSAFETY, SnowflakeParserSAML_IDENTITY_PROVIDER, SnowflakeParserSAVE_OLD_URL, SnowflakeParserSCALING_POLICY, SnowflakeParserSCHEDULE, SnowflakeParserSCHEDULER, SnowflakeParserSCHEMA, SnowflakeParserSCHEMAS, SnowflakeParserSCHEME, SnowflakeParserSCIM, SnowflakeParserSCIM_CLIENT, SnowflakeParserSCRIPT, SnowflakeParserSEARCH, SnowflakeParserSECONDARY, SnowflakeParserSECONDARY_ONLY, SnowflakeParserSECONDARY_ROLE, SnowflakeParserSECONDS, SnowflakeParserSECRET, SnowflakeParserSECURE, SnowflakeParserSECURITY, SnowflakeParserSECURITYADMIN, SnowflakeParserSEED, SnowflakeParserSELF, SnowflakeParserSEQUENCE, SnowflakeParserSEQUENCES, SnowflakeParserSERVER, SnowflakeParserSERVICE, SnowflakeParserSESSION, SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, SnowflakeParserSESSION_POLICY, SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, SnowflakeParserSETS, SnowflakeParserSETUSER, SnowflakeParserSHARE, SnowflakeParserSHARED, SnowflakeParserSHARES, SnowflakeParserSHARE_RESTRICTIONS, SnowflakeParserSHOW, SnowflakeParserSHOWPLAN, SnowflakeParserSHOWPLAN_ALL, SnowflakeParserSHOWPLAN_TEXT, SnowflakeParserSHOWPLAN_XML, SnowflakeParserSHOW_INITIAL_ROWS, SnowflakeParserSIGNATURE, SnowflakeParserSIMPLE, SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, SnowflakeParserSINGLE_USER, SnowflakeParserSIZE, SnowflakeParserSIZE_LIMIT, SnowflakeParserSKIP_, SnowflakeParserSKIP_BLANK_LINES, SnowflakeParserSKIP_BYTE_ORDER_MARK, SnowflakeParserSKIP_FILE, SnowflakeParserSKIP_FILE_N, SnowflakeParserSKIP_HEADER, SnowflakeParserSMALL, SnowflakeParserSNAPPY, SnowflakeParserSNAPPY_COMPRESSION, SnowflakeParserSOUNDEX, SnowflakeParserSOURCE, SnowflakeParserSOURCE_COMPRESSION, SnowflakeParserSPACE_KEYWORD, SnowflakeParserSPARSE, SnowflakeParserSPECIFICATION, SnowflakeParserSPLIT, SnowflakeParserSPLIT_PART, SnowflakeParserSQL, SnowflakeParserSSO_LOGIN_PAGE, SnowflakeParserSTAGE, SnowflakeParserSTAGES, SnowflakeParserSTAGE_COPY_OPTIONS, SnowflakeParserSTAGE_FILE_FORMAT, SnowflakeParserSTANDARD, SnowflakeParserSTANDBY, SnowflakeParserSTARTED, SnowflakeParserSTARTS, SnowflakeParserSTART_DATE, SnowflakeParserSTART_TIMESTAMP, SnowflakeParserSTATE, SnowflakeParserSTATEMENT, SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, SnowflakeParserSTATIC, SnowflakeParserSTATISTICS, SnowflakeParserSTATS, SnowflakeParserSTATS_DATE, SnowflakeParserSTATS_STREAM, SnowflakeParserSTATUS, SnowflakeParserSTATUSONLY, SnowflakeParserSTDEV, SnowflakeParserSTDEVP, SnowflakeParserSTOP, SnowflakeParserSTOPLIST, SnowflakeParserSTOPPED, SnowflakeParserSTORAGE, SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, SnowflakeParserSTORAGE_AWS_OBJECT_ACL, SnowflakeParserSTORAGE_AWS_ROLE_ARN, SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, SnowflakeParserSTORAGE_INTEGRATION, SnowflakeParserSTORAGE_PROVIDER, SnowflakeParserSTR, SnowflakeParserSTREAM, SnowflakeParserSTREAMS, SnowflakeParserSTRICT, SnowflakeParserSTRICT_JSON_OUTPUT, SnowflakeParserSTRING_AGG, SnowflakeParserSTRING_ESCAPE, SnowflakeParserSTRIP_NULL_VALUES, SnowflakeParserSTRIP_OUTER_ARRAY, SnowflakeParserSTRIP_OUTER_ELEMENT, SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING, SnowflakeParserSUM, SnowflakeParserSUPPORTED, SnowflakeParserSUSPEND, SnowflakeParserSUSPENDED, SnowflakeParserSUSPEND_IMMEDIATE, SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, SnowflakeParserSWAP, SnowflakeParserSWITCH, SnowflakeParserSYNC_PASSWORD, SnowflakeParserSYSADMIN, SnowflakeParserSYSTEM, SnowflakeParserSYSTEM_USER, SnowflakeParserTABLEAU_DESKTOP, SnowflakeParserTABLEAU_SERVER, SnowflakeParserTABLES, SnowflakeParserTABLE_FORMAT, SnowflakeParserTABULAR, SnowflakeParserTAG, SnowflakeParserTAGS, SnowflakeParserTARGET, SnowflakeParserTARGET_LAG, SnowflakeParserTASK, SnowflakeParserTASKS, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserTERSE, SnowflakeParserTEXTSIZE, SnowflakeParserTIES, SnowflakeParserTIME, SnowflakeParserTIMEADD, SnowflakeParserTIMEDIFF, SnowflakeParserTIMEOUT, SnowflakeParserTIMER, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_FORMAT, SnowflakeParserTIMESTAMP_INPUT_FORMAT, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_TYPE_MAPPING, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMPADD, SnowflakeParserTIMESTAMPDIFF, SnowflakeParserTIMEZONE, SnowflakeParserTIME_FORMAT, SnowflakeParserTIME_INPUT_FORMAT, SnowflakeParserTIME_OUTPUT_FORMAT, SnowflakeParserTO_BOOLEAN, SnowflakeParserTO_DATE, SnowflakeParserTOP, SnowflakeParserTORN_PAGE_DETECTION, SnowflakeParserTRACKING, SnowflakeParserTRACK_CAUSALITY, SnowflakeParserTRAN, SnowflakeParserTRANSACTION, SnowflakeParserTRANSACTIONS, SnowflakeParserTRANSACTION_ABORT_ON_ERROR, SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, SnowflakeParserTRANSACTION_ID, SnowflakeParserTRANSFORM_NOISE_WORDS, SnowflakeParserTRANSIENT, SnowflakeParserTRANSLATE, SnowflakeParserTRIGGERS, SnowflakeParserTRIM, SnowflakeParserTRIM_SPACE, SnowflakeParserTRIPLE_DES, SnowflakeParserTRUNCATE, SnowflakeParserTRUNCATECOLUMNS, SnowflakeParserTRUSTWORTHY, SnowflakeParserTRY, SnowflakeParserTSEQUAL, SnowflakeParserTSQL, SnowflakeParserTWO_DIGIT_CENTURY_START, SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, SnowflakeParserTYPE, SnowflakeParserTYPEPROPERTY, SnowflakeParserTYPE_ID, SnowflakeParserTYPE_NAME, SnowflakeParserTYPE_WARNING, SnowflakeParserUN, SnowflakeParserUNBOUNDED, SnowflakeParserUNCHECKED, SnowflakeParserUNCOMMITTED, SnowflakeParserUNDROP, SnowflakeParserUNICODE, SnowflakeParserUNKNOWN, SnowflakeParserUNLIMITED, SnowflakeParserUNLOCK, SnowflakeParserUNMASK, SnowflakeParserUNMATCHED, SnowflakeParserUNPIVOT, SnowflakeParserUNSAFE, SnowflakeParserUNSET, SnowflakeParserUNSUPPORTED_DDL_ACTION, SnowflakeParserUOW, SnowflakeParserUPDLOCK, SnowflakeParserUPPER, SnowflakeParserURL, SnowflakeParserUSAGE, SnowflakeParserUSE, SnowflakeParserUSED, SnowflakeParserUSER, SnowflakeParserUSERADMIN, SnowflakeParserUSERS, SnowflakeParserUSER_SPECIFIED, SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, SnowflakeParserUSER_TASK_TIMEOUT_MS, SnowflakeParserUSE_ANY_ROLE, SnowflakeParserUSE_CACHED_RESULT, SnowflakeParserVALIDATE, SnowflakeParserVALIDATION, SnowflakeParserVALIDATION_MODE, SnowflakeParserVALID_XML, SnowflakeParserVALUE, SnowflakeParserVAR, SnowflakeParserVARIABLES, SnowflakeParserVARP, SnowflakeParserVARYING, SnowflakeParserVERSION, SnowflakeParserVIEWS, SnowflakeParserVIEW_METADATA, SnowflakeParserVISIBILITY, SnowflakeParserVOLATILE, SnowflakeParserWAIT, SnowflakeParserWAREHOUSE, SnowflakeParserWAREHOUSES, SnowflakeParserWAREHOUSE_SIZE, SnowflakeParserWEEKLY, SnowflakeParserWEEK_OF_YEAR_POLICY, SnowflakeParserWEEK_START, SnowflakeParserWELL_FORMED_XML, SnowflakeParserWITHIN, SnowflakeParserWITHOUT, SnowflakeParserWITHOUT_ARRAY_WRAPPER, SnowflakeParserWORK, SnowflakeParserWORKLOAD, SnowflakeParserWRITE, SnowflakeParserXLARGE, SnowflakeParserXLOCK, SnowflakeParserXML, SnowflakeParserXML_Q, SnowflakeParserXSMALL, SnowflakeParserXXLARGE, SnowflakeParserXXXLARGE, SnowflakeParserYEARLY, SnowflakeParserZSTD, SnowflakeParserARRAY, SnowflakeParserARRAY_Q, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserCHAR_VARYING, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNCHAR_VARYING, SnowflakeParserNUMERIC, SnowflakeParserNVARCHAR, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT, SnowflakeParserLISTAGG, SnowflakeParserDUMMY, SnowflakeParserDOUBLE_QUOTE_ID, SnowflakeParserDOUBLE_QUOTE_BLANK, SnowflakeParserID, SnowflakeParserID2, SnowflakeParserRR_BRACKET, SnowflakeParserSEMI: + p.SetState(9958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSCHEMA { + { + p.SetState(9957) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9961) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1251, p.GetParserRuleContext()) == 1 { + { + p.SetState(9960) + p.Schema_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(9968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTARTS { + { + p.SetState(9967) + p.Starts_with() + } + + } + p.SetState(9971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIMIT { + { + p.SetState(9970) + p.Limit_rows() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_failover_groupsContext is an interface to support dynamic dispatch. +type IShow_failover_groupsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + GROUPS() antlr.TerminalNode + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + Id_() IId_Context + + // IsShow_failover_groupsContext differentiates from other interfaces. + IsShow_failover_groupsContext() +} + +type Show_failover_groupsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_failover_groupsContext() *Show_failover_groupsContext { + var p = new(Show_failover_groupsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_failover_groups + return p +} + +func InitEmptyShow_failover_groupsContext(p *Show_failover_groupsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_failover_groups +} + +func (*Show_failover_groupsContext) IsShow_failover_groupsContext() {} + +func NewShow_failover_groupsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_failover_groupsContext { + var p = new(Show_failover_groupsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_failover_groups + + return p +} + +func (s *Show_failover_groupsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_failover_groupsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_failover_groupsContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, 0) +} + +func (s *Show_failover_groupsContext) GROUPS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUPS, 0) +} + +func (s *Show_failover_groupsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_failover_groupsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_failover_groupsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_failover_groupsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_failover_groupsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_failover_groupsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_failover_groups(s) + } +} + +func (s *Show_failover_groupsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_failover_groups(s) + } +} + +func (s *Show_failover_groupsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_failover_groups(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_failover_groups() (localctx IShow_failover_groupsContext) { + localctx = NewShow_failover_groupsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 740, SnowflakeParserRULE_show_failover_groups) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9973) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9974) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9975) + p.Match(SnowflakeParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(9976) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9977) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9978) + p.Id_() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_file_formatsContext is an interface to support dynamic dispatch. +type IShow_file_formatsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + FILE() antlr.TerminalNode + FORMATS() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsShow_file_formatsContext differentiates from other interfaces. + IsShow_file_formatsContext() +} + +type Show_file_formatsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_file_formatsContext() *Show_file_formatsContext { + var p = new(Show_file_formatsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_file_formats + return p +} + +func InitEmptyShow_file_formatsContext(p *Show_file_formatsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_file_formats +} + +func (*Show_file_formatsContext) IsShow_file_formatsContext() {} + +func NewShow_file_formatsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_file_formatsContext { + var p = new(Show_file_formatsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_file_formats + + return p +} + +func (s *Show_file_formatsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_file_formatsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_file_formatsContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Show_file_formatsContext) FORMATS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMATS, 0) +} + +func (s *Show_file_formatsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_file_formatsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_file_formatsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_file_formatsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_file_formatsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_file_formatsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_file_formatsContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_file_formatsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_file_formatsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_file_formatsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_file_formats(s) + } +} + +func (s *Show_file_formatsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_file_formats(s) + } +} + +func (s *Show_file_formatsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_file_formats(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_file_formats() (localctx IShow_file_formatsContext) { + localctx = NewShow_file_formatsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 742, SnowflakeParserRULE_show_file_formats) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9981) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9982) + p.Match(SnowflakeParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9983) + p.Match(SnowflakeParserFORMATS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(9984) + p.Like_pattern() + } + + } + p.SetState(9998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(9987) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1258, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9988) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(9989) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(9990) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9991) + p.Id_() + } + + case 4: + { + p.SetState(9992) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(9993) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9994) + p.Schema_name() + } + + case 6: + { + p.SetState(9995) + p.Schema_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 +} + +// IShow_functionsContext is an interface to support dynamic dispatch. +type IShow_functionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + SCHEMA() antlr.TerminalNode + + // IsShow_functionsContext differentiates from other interfaces. + IsShow_functionsContext() +} + +type Show_functionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_functionsContext() *Show_functionsContext { + var p = new(Show_functionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_functions + return p +} + +func InitEmptyShow_functionsContext(p *Show_functionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_functions +} + +func (*Show_functionsContext) IsShow_functionsContext() {} + +func NewShow_functionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_functionsContext { + var p = new(Show_functionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_functions + + return p +} + +func (s *Show_functionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_functionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_functionsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTIONS, 0) +} + +func (s *Show_functionsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_functionsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_functionsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_functionsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_functionsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_functionsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_functionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_functionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_functionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_functions(s) + } +} + +func (s *Show_functionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_functions(s) + } +} + +func (s *Show_functionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_functions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_functions() (localctx IShow_functionsContext) { + localctx = NewShow_functionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 744, SnowflakeParserRULE_show_functions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10000) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10001) + p.Match(SnowflakeParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10002) + p.Like_pattern() + } + + } + p.SetState(10016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10005) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1261, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10006) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(10007) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(10008) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10009) + p.Id_() + } + + case 4: + { + p.SetState(10010) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(10011) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10012) + p.Id_() + } + + case 6: + { + p.SetState(10013) + p.Id_() + } + + 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 +} + +// IShow_global_accountsContext is an interface to support dynamic dispatch. +type IShow_global_accountsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + ACCOUNTS() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_global_accountsContext differentiates from other interfaces. + IsShow_global_accountsContext() +} + +type Show_global_accountsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_global_accountsContext() *Show_global_accountsContext { + var p = new(Show_global_accountsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_global_accounts + return p +} + +func InitEmptyShow_global_accountsContext(p *Show_global_accountsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_global_accounts +} + +func (*Show_global_accountsContext) IsShow_global_accountsContext() {} + +func NewShow_global_accountsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_global_accountsContext { + var p = new(Show_global_accountsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_global_accounts + + return p +} + +func (s *Show_global_accountsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_global_accountsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_global_accountsContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGLOBAL, 0) +} + +func (s *Show_global_accountsContext) ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTS, 0) +} + +func (s *Show_global_accountsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_global_accountsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_global_accountsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_global_accountsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_global_accounts(s) + } +} + +func (s *Show_global_accountsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_global_accounts(s) + } +} + +func (s *Show_global_accountsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_global_accounts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_global_accounts() (localctx IShow_global_accountsContext) { + localctx = NewShow_global_accountsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 746, SnowflakeParserRULE_show_global_accounts) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10018) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10019) + p.Match(SnowflakeParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10020) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10021) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_grantsContext is an interface to support dynamic dispatch. +type IShow_grantsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + GRANTS() antlr.TerminalNode + Show_grants_opts() IShow_grants_optsContext + FUTURE() antlr.TerminalNode + IN() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + DATABASE() antlr.TerminalNode + Id_() IId_Context + + // IsShow_grantsContext differentiates from other interfaces. + IsShow_grantsContext() +} + +type Show_grantsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_grantsContext() *Show_grantsContext { + var p = new(Show_grantsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_grants + return p +} + +func InitEmptyShow_grantsContext(p *Show_grantsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_grants +} + +func (*Show_grantsContext) IsShow_grantsContext() {} + +func NewShow_grantsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_grantsContext { + var p = new(Show_grantsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_grants + + return p +} + +func (s *Show_grantsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_grantsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_grantsContext) GRANTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANTS, 0) +} + +func (s *Show_grantsContext) Show_grants_opts() IShow_grants_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShow_grants_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShow_grants_optsContext) +} + +func (s *Show_grantsContext) FUTURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUTURE, 0) +} + +func (s *Show_grantsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_grantsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_grantsContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_grantsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_grantsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_grantsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_grantsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_grantsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_grants(s) + } +} + +func (s *Show_grantsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_grants(s) + } +} + +func (s *Show_grantsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_grants(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_grants() (localctx IShow_grantsContext) { + localctx = NewShow_grantsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 748, SnowflakeParserRULE_show_grants) + var _la int + + p.SetState(10041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1265, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10024) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10025) + p.Match(SnowflakeParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOF || _la == SnowflakeParserON || _la == SnowflakeParserTO { + { + p.SetState(10026) + p.Show_grants_opts() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10029) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10030) + p.Match(SnowflakeParserFUTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10031) + p.Match(SnowflakeParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10032) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10033) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10034) + p.Schema_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10035) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10036) + p.Match(SnowflakeParserFUTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10037) + p.Match(SnowflakeParserGRANTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10038) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10039) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10040) + p.Id_() + } + + 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 +} + +// IShow_grants_optsContext is an interface to support dynamic dispatch. +type IShow_grants_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + Object_type() IObject_typeContext + Object_name() IObject_nameContext + TO() antlr.TerminalNode + ROLE() antlr.TerminalNode + Id_() IId_Context + USER() antlr.TerminalNode + SHARE() antlr.TerminalNode + OF() antlr.TerminalNode + + // IsShow_grants_optsContext differentiates from other interfaces. + IsShow_grants_optsContext() +} + +type Show_grants_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_grants_optsContext() *Show_grants_optsContext { + var p = new(Show_grants_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_grants_opts + return p +} + +func InitEmptyShow_grants_optsContext(p *Show_grants_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_grants_opts +} + +func (*Show_grants_optsContext) IsShow_grants_optsContext() {} + +func NewShow_grants_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_grants_optsContext { + var p = new(Show_grants_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_grants_opts + + return p +} + +func (s *Show_grants_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_grants_optsContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Show_grants_optsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_grants_optsContext) Object_type() IObject_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_typeContext) +} + +func (s *Show_grants_optsContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Show_grants_optsContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *Show_grants_optsContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Show_grants_optsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_grants_optsContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Show_grants_optsContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Show_grants_optsContext) OF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOF, 0) +} + +func (s *Show_grants_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_grants_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_grants_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_grants_opts(s) + } +} + +func (s *Show_grants_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_grants_opts(s) + } +} + +func (s *Show_grants_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_grants_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_grants_opts() (localctx IShow_grants_optsContext) { + localctx = NewShow_grants_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 750, SnowflakeParserRULE_show_grants_opts) + p.SetState(10064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1267, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10043) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10044) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10045) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10046) + p.Object_type() + } + { + p.SetState(10047) + p.Object_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10049) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserROLE: + { + p.SetState(10050) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10051) + p.Id_() + } + + case SnowflakeParserUSER: + { + p.SetState(10052) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10053) + p.Id_() + } + + case SnowflakeParserSHARE: + { + p.SetState(10054) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10055) + p.Id_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10058) + p.Match(SnowflakeParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10059) + p.Match(SnowflakeParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10060) + p.Id_() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10061) + p.Match(SnowflakeParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10062) + p.Match(SnowflakeParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10063) + p.Id_() + } + + 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 +} + +// IShow_integrationsContext is an interface to support dynamic dispatch. +type IShow_integrationsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + INTEGRATIONS() antlr.TerminalNode + Like_pattern() ILike_patternContext + API() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + SECURITY() antlr.TerminalNode + STORAGE() antlr.TerminalNode + + // IsShow_integrationsContext differentiates from other interfaces. + IsShow_integrationsContext() +} + +type Show_integrationsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_integrationsContext() *Show_integrationsContext { + var p = new(Show_integrationsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_integrations + return p +} + +func InitEmptyShow_integrationsContext(p *Show_integrationsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_integrations +} + +func (*Show_integrationsContext) IsShow_integrationsContext() {} + +func NewShow_integrationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_integrationsContext { + var p = new(Show_integrationsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_integrations + + return p +} + +func (s *Show_integrationsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_integrationsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_integrationsContext) INTEGRATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATIONS, 0) +} + +func (s *Show_integrationsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_integrationsContext) API() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI, 0) +} + +func (s *Show_integrationsContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION, 0) +} + +func (s *Show_integrationsContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Show_integrationsContext) STORAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE, 0) +} + +func (s *Show_integrationsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_integrationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_integrationsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_integrations(s) + } +} + +func (s *Show_integrationsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_integrations(s) + } +} + +func (s *Show_integrationsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_integrations(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_integrations() (localctx IShow_integrationsContext) { + localctx = NewShow_integrationsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 752, SnowflakeParserRULE_show_integrations) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10066) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAPI || _la == SnowflakeParserNOTIFICATION || _la == SnowflakeParserSECURITY || _la == SnowflakeParserSTORAGE { + { + p.SetState(10067) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAPI || _la == SnowflakeParserNOTIFICATION || _la == SnowflakeParserSECURITY || _la == SnowflakeParserSTORAGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10070) + p.Match(SnowflakeParserINTEGRATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10071) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_locksContext is an interface to support dynamic dispatch. +type IShow_locksContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + LOCKS() antlr.TerminalNode + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + + // IsShow_locksContext differentiates from other interfaces. + IsShow_locksContext() +} + +type Show_locksContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_locksContext() *Show_locksContext { + var p = new(Show_locksContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_locks + return p +} + +func InitEmptyShow_locksContext(p *Show_locksContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_locks +} + +func (*Show_locksContext) IsShow_locksContext() {} + +func NewShow_locksContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_locksContext { + var p = new(Show_locksContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_locks + + return p +} + +func (s *Show_locksContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_locksContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_locksContext) LOCKS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCKS, 0) +} + +func (s *Show_locksContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_locksContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_locksContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_locksContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_locksContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_locks(s) + } +} + +func (s *Show_locksContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_locks(s) + } +} + +func (s *Show_locksContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_locks(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_locks() (localctx IShow_locksContext) { + localctx = NewShow_locksContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 754, SnowflakeParserRULE_show_locks) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10074) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10075) + p.Match(SnowflakeParserLOCKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10076) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10077) + p.Match(SnowflakeParserACCOUNT) + 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 +} + +// IShow_managed_accountsContext is an interface to support dynamic dispatch. +type IShow_managed_accountsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + MANAGED() antlr.TerminalNode + ACCOUNTS() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_managed_accountsContext differentiates from other interfaces. + IsShow_managed_accountsContext() +} + +type Show_managed_accountsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_managed_accountsContext() *Show_managed_accountsContext { + var p = new(Show_managed_accountsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_managed_accounts + return p +} + +func InitEmptyShow_managed_accountsContext(p *Show_managed_accountsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_managed_accounts +} + +func (*Show_managed_accountsContext) IsShow_managed_accountsContext() {} + +func NewShow_managed_accountsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_managed_accountsContext { + var p = new(Show_managed_accountsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_managed_accounts + + return p +} + +func (s *Show_managed_accountsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_managed_accountsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_managed_accountsContext) MANAGED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMANAGED, 0) +} + +func (s *Show_managed_accountsContext) ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTS, 0) +} + +func (s *Show_managed_accountsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_managed_accountsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_managed_accountsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_managed_accountsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_managed_accounts(s) + } +} + +func (s *Show_managed_accountsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_managed_accounts(s) + } +} + +func (s *Show_managed_accountsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_managed_accounts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_managed_accounts() (localctx IShow_managed_accountsContext) { + localctx = NewShow_managed_accountsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 756, SnowflakeParserRULE_show_managed_accounts) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10080) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10081) + p.Match(SnowflakeParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10082) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10083) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_masking_policiesContext is an interface to support dynamic dispatch. +type IShow_masking_policiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + MASKING() antlr.TerminalNode + POLICIES() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_masking_policiesContext differentiates from other interfaces. + IsShow_masking_policiesContext() +} + +type Show_masking_policiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_masking_policiesContext() *Show_masking_policiesContext { + var p = new(Show_masking_policiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_masking_policies + return p +} + +func InitEmptyShow_masking_policiesContext(p *Show_masking_policiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_masking_policies +} + +func (*Show_masking_policiesContext) IsShow_masking_policiesContext() {} + +func NewShow_masking_policiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_masking_policiesContext { + var p = new(Show_masking_policiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_masking_policies + + return p +} + +func (s *Show_masking_policiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_masking_policiesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_masking_policiesContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Show_masking_policiesContext) POLICIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICIES, 0) +} + +func (s *Show_masking_policiesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_masking_policiesContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_masking_policiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_masking_policiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_masking_policiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_masking_policies(s) + } +} + +func (s *Show_masking_policiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_masking_policies(s) + } +} + +func (s *Show_masking_policiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_masking_policies(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_masking_policies() (localctx IShow_masking_policiesContext) { + localctx = NewShow_masking_policiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 758, SnowflakeParserRULE_show_masking_policies) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10086) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10087) + p.Match(SnowflakeParserMASKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10088) + p.Match(SnowflakeParserPOLICIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10089) + p.Like_pattern() + } + + } + p.SetState(10093) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10092) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_objContext is an interface to support dynamic dispatch. +type IIn_objContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsIn_objContext differentiates from other interfaces. + IsIn_objContext() +} + +type In_objContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIn_objContext() *In_objContext { + var p = new(In_objContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_in_obj + return p +} + +func InitEmptyIn_objContext(p *In_objContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_in_obj +} + +func (*In_objContext) IsIn_objContext() {} + +func NewIn_objContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_objContext { + var p = new(In_objContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_in_obj + + return p +} + +func (s *In_objContext) GetParser() antlr.Parser { return s.parser } + +func (s *In_objContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *In_objContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *In_objContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *In_objContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *In_objContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *In_objContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *In_objContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_objContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *In_objContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIn_obj(s) + } +} + +func (s *In_objContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIn_obj(s) + } +} + +func (s *In_objContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIn_obj(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) In_obj() (localctx IIn_objContext) { + localctx = NewIn_objContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 760, SnowflakeParserRULE_in_obj) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10095) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1274, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10096) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(10097) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(10098) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10099) + p.Id_() + } + + case 4: + { + p.SetState(10100) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(10101) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10102) + p.Schema_name() + } + + case 6: + { + p.SetState(10103) + p.Schema_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 +} + +// IIn_obj_2Context is an interface to support dynamic dispatch. +type IIn_obj_2Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + Id_() IId_Context + Schema_name() ISchema_nameContext + + // IsIn_obj_2Context differentiates from other interfaces. + IsIn_obj_2Context() +} + +type In_obj_2Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIn_obj_2Context() *In_obj_2Context { + var p = new(In_obj_2Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_in_obj_2 + return p +} + +func InitEmptyIn_obj_2Context(p *In_obj_2Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_in_obj_2 +} + +func (*In_obj_2Context) IsIn_obj_2Context() {} + +func NewIn_obj_2Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_obj_2Context { + var p = new(In_obj_2Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_in_obj_2 + + return p +} + +func (s *In_obj_2Context) GetParser() antlr.Parser { return s.parser } + +func (s *In_obj_2Context) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *In_obj_2Context) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *In_obj_2Context) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *In_obj_2Context) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *In_obj_2Context) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *In_obj_2Context) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *In_obj_2Context) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *In_obj_2Context) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *In_obj_2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_obj_2Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *In_obj_2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIn_obj_2(s) + } +} + +func (s *In_obj_2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIn_obj_2(s) + } +} + +func (s *In_obj_2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIn_obj_2(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) In_obj_2() (localctx IIn_obj_2Context) { + localctx = NewIn_obj_2Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 762, SnowflakeParserRULE_in_obj_2) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10106) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1277, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10107) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(10108) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10110) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(10109) + p.Id_() + } + + } + + case 3: + { + p.SetState(10112) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(10113) + p.Schema_name() + } + + } + + case 4: + { + p.SetState(10116) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(10117) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10118) + p.Object_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 +} + +// IShow_materialized_viewsContext is an interface to support dynamic dispatch. +type IShow_materialized_viewsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEWS() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_materialized_viewsContext differentiates from other interfaces. + IsShow_materialized_viewsContext() +} + +type Show_materialized_viewsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_materialized_viewsContext() *Show_materialized_viewsContext { + var p = new(Show_materialized_viewsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_materialized_views + return p +} + +func InitEmptyShow_materialized_viewsContext(p *Show_materialized_viewsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_materialized_views +} + +func (*Show_materialized_viewsContext) IsShow_materialized_viewsContext() {} + +func NewShow_materialized_viewsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_materialized_viewsContext { + var p = new(Show_materialized_viewsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_materialized_views + + return p +} + +func (s *Show_materialized_viewsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_materialized_viewsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_materialized_viewsContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATERIALIZED, 0) +} + +func (s *Show_materialized_viewsContext) VIEWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEWS, 0) +} + +func (s *Show_materialized_viewsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_materialized_viewsContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_materialized_viewsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_materialized_viewsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_materialized_viewsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_materialized_views(s) + } +} + +func (s *Show_materialized_viewsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_materialized_views(s) + } +} + +func (s *Show_materialized_viewsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_materialized_views(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_materialized_views() (localctx IShow_materialized_viewsContext) { + localctx = NewShow_materialized_viewsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 764, SnowflakeParserRULE_show_materialized_views) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10121) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10122) + p.Match(SnowflakeParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10123) + p.Match(SnowflakeParserVIEWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10124) + p.Like_pattern() + } + + } + p.SetState(10128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10127) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_network_policiesContext is an interface to support dynamic dispatch. +type IShow_network_policiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + NETWORK() antlr.TerminalNode + POLICIES() antlr.TerminalNode + + // IsShow_network_policiesContext differentiates from other interfaces. + IsShow_network_policiesContext() +} + +type Show_network_policiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_network_policiesContext() *Show_network_policiesContext { + var p = new(Show_network_policiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_network_policies + return p +} + +func InitEmptyShow_network_policiesContext(p *Show_network_policiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_network_policies +} + +func (*Show_network_policiesContext) IsShow_network_policiesContext() {} + +func NewShow_network_policiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_network_policiesContext { + var p = new(Show_network_policiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_network_policies + + return p +} + +func (s *Show_network_policiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_network_policiesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_network_policiesContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Show_network_policiesContext) POLICIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICIES, 0) +} + +func (s *Show_network_policiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_network_policiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_network_policiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_network_policies(s) + } +} + +func (s *Show_network_policiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_network_policies(s) + } +} + +func (s *Show_network_policiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_network_policies(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_network_policies() (localctx IShow_network_policiesContext) { + localctx = NewShow_network_policiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 766, SnowflakeParserRULE_show_network_policies) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10130) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10131) + p.Match(SnowflakeParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10132) + p.Match(SnowflakeParserPOLICIES) + 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 +} + +// IShow_objectsContext is an interface to support dynamic dispatch. +type IShow_objectsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + OBJECTS() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_objectsContext differentiates from other interfaces. + IsShow_objectsContext() +} + +type Show_objectsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_objectsContext() *Show_objectsContext { + var p = new(Show_objectsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_objects + return p +} + +func InitEmptyShow_objectsContext(p *Show_objectsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_objects +} + +func (*Show_objectsContext) IsShow_objectsContext() {} + +func NewShow_objectsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_objectsContext { + var p = new(Show_objectsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_objects + + return p +} + +func (s *Show_objectsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_objectsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_objectsContext) OBJECTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECTS, 0) +} + +func (s *Show_objectsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_objectsContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_objectsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_objectsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_objectsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_objects(s) + } +} + +func (s *Show_objectsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_objects(s) + } +} + +func (s *Show_objectsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_objects(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_objects() (localctx IShow_objectsContext) { + localctx = NewShow_objectsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 768, SnowflakeParserRULE_show_objects) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10134) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10135) + p.Match(SnowflakeParserOBJECTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10136) + p.Like_pattern() + } + + } + p.SetState(10140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10139) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_organization_accountsContext is an interface to support dynamic dispatch. +type IShow_organization_accountsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + ORGANIZATION() antlr.TerminalNode + ACCOUNTS() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_organization_accountsContext differentiates from other interfaces. + IsShow_organization_accountsContext() +} + +type Show_organization_accountsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_organization_accountsContext() *Show_organization_accountsContext { + var p = new(Show_organization_accountsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_organization_accounts + return p +} + +func InitEmptyShow_organization_accountsContext(p *Show_organization_accountsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_organization_accounts +} + +func (*Show_organization_accountsContext) IsShow_organization_accountsContext() {} + +func NewShow_organization_accountsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_organization_accountsContext { + var p = new(Show_organization_accountsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_organization_accounts + + return p +} + +func (s *Show_organization_accountsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_organization_accountsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_organization_accountsContext) ORGANIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORGANIZATION, 0) +} + +func (s *Show_organization_accountsContext) ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTS, 0) +} + +func (s *Show_organization_accountsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_organization_accountsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_organization_accountsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_organization_accountsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_organization_accounts(s) + } +} + +func (s *Show_organization_accountsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_organization_accounts(s) + } +} + +func (s *Show_organization_accountsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_organization_accounts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_organization_accounts() (localctx IShow_organization_accountsContext) { + localctx = NewShow_organization_accountsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 770, SnowflakeParserRULE_show_organization_accounts) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10142) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10143) + p.Match(SnowflakeParserORGANIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10144) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10145) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_forContext is an interface to support dynamic dispatch. +type IIn_forContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN() antlr.TerminalNode + FOR() antlr.TerminalNode + + // IsIn_forContext differentiates from other interfaces. + IsIn_forContext() +} + +type In_forContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIn_forContext() *In_forContext { + var p = new(In_forContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_in_for + return p +} + +func InitEmptyIn_forContext(p *In_forContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_in_for +} + +func (*In_forContext) IsIn_forContext() {} + +func NewIn_forContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_forContext { + var p = new(In_forContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_in_for + + return p +} + +func (s *In_forContext) GetParser() antlr.Parser { return s.parser } + +func (s *In_forContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *In_forContext) FOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFOR, 0) +} + +func (s *In_forContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_forContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *In_forContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIn_for(s) + } +} + +func (s *In_forContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIn_for(s) + } +} + +func (s *In_forContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIn_for(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) In_for() (localctx IIn_forContext) { + localctx = NewIn_forContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 772, SnowflakeParserRULE_in_for) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10148) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserFOR || _la == SnowflakeParserIN) { + 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 +} + +// IShow_parametersContext is an interface to support dynamic dispatch. +type IShow_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_for() IIn_forContext + SESSION() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + USER() antlr.TerminalNode + TABLE() antlr.TerminalNode + Object_name() IObject_nameContext + WAREHOUSE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + TASK() antlr.TerminalNode + Id_() IId_Context + + // IsShow_parametersContext differentiates from other interfaces. + IsShow_parametersContext() +} + +type Show_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_parametersContext() *Show_parametersContext { + var p = new(Show_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_parameters + return p +} + +func InitEmptyShow_parametersContext(p *Show_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_parameters +} + +func (*Show_parametersContext) IsShow_parametersContext() {} + +func NewShow_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_parametersContext { + var p = new(Show_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_parameters + + return p +} + +func (s *Show_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_parametersContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_parametersContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARAMETERS, 0) +} + +func (s *Show_parametersContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_parametersContext) In_for() IIn_forContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_forContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_forContext) +} + +func (s *Show_parametersContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Show_parametersContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_parametersContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Show_parametersContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Show_parametersContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Show_parametersContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Show_parametersContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_parametersContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_parametersContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Show_parametersContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_parameters(s) + } +} + +func (s *Show_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_parameters(s) + } +} + +func (s *Show_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_parameters() (localctx IShow_parametersContext) { + localctx = NewShow_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 774, SnowflakeParserRULE_show_parameters) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10150) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10151) + p.Match(SnowflakeParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10152) + p.Like_pattern() + } + + } + p.SetState(10170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFOR || _la == SnowflakeParserIN { + { + p.SetState(10155) + p.In_for() + } + p.SetState(10168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSESSION: + { + p.SetState(10156) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserACCOUNT: + { + p.SetState(10157) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUSER: + { + p.SetState(10158) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10160) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(10159) + p.Id_() + } + + } + + case SnowflakeParserDATABASE, SnowflakeParserSCHEMA, SnowflakeParserTASK, SnowflakeParserWAREHOUSE: + { + p.SetState(10162) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDATABASE || _la == SnowflakeParserSCHEMA || _la == SnowflakeParserTASK || _la == SnowflakeParserWAREHOUSE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(10163) + p.Id_() + } + + } + + case SnowflakeParserTABLE: + { + p.SetState(10166) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10167) + p.Object_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 +} + +// IShow_pipesContext is an interface to support dynamic dispatch. +type IShow_pipesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + PIPES() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_pipesContext differentiates from other interfaces. + IsShow_pipesContext() +} + +type Show_pipesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_pipesContext() *Show_pipesContext { + var p = new(Show_pipesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_pipes + return p +} + +func InitEmptyShow_pipesContext(p *Show_pipesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_pipes +} + +func (*Show_pipesContext) IsShow_pipesContext() {} + +func NewShow_pipesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_pipesContext { + var p = new(Show_pipesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_pipes + + return p +} + +func (s *Show_pipesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_pipesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_pipesContext) PIPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPES, 0) +} + +func (s *Show_pipesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_pipesContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_pipesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_pipesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_pipesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_pipes(s) + } +} + +func (s *Show_pipesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_pipes(s) + } +} + +func (s *Show_pipesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_pipes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_pipes() (localctx IShow_pipesContext) { + localctx = NewShow_pipesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 776, SnowflakeParserRULE_show_pipes) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10172) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10173) + p.Match(SnowflakeParserPIPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10174) + p.Like_pattern() + } + + } + p.SetState(10178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10177) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_primary_keysContext is an interface to support dynamic dispatch. +type IShow_primary_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEYS() antlr.TerminalNode + TERSE() antlr.TerminalNode + In_obj_2() IIn_obj_2Context + + // IsShow_primary_keysContext differentiates from other interfaces. + IsShow_primary_keysContext() +} + +type Show_primary_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_primary_keysContext() *Show_primary_keysContext { + var p = new(Show_primary_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_primary_keys + return p +} + +func InitEmptyShow_primary_keysContext(p *Show_primary_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_primary_keys +} + +func (*Show_primary_keysContext) IsShow_primary_keysContext() {} + +func NewShow_primary_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_primary_keysContext { + var p = new(Show_primary_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_primary_keys + + return p +} + +func (s *Show_primary_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_primary_keysContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_primary_keysContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Show_primary_keysContext) KEYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEYS, 0) +} + +func (s *Show_primary_keysContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Show_primary_keysContext) In_obj_2() IIn_obj_2Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_obj_2Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_obj_2Context) +} + +func (s *Show_primary_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_primary_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_primary_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_primary_keys(s) + } +} + +func (s *Show_primary_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_primary_keys(s) + } +} + +func (s *Show_primary_keysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_primary_keys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_primary_keys() (localctx IShow_primary_keysContext) { + localctx = NewShow_primary_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 778, SnowflakeParserRULE_show_primary_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10180) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTERSE { + { + p.SetState(10181) + p.Match(SnowflakeParserTERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10184) + p.Match(SnowflakeParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10185) + p.Match(SnowflakeParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10186) + p.In_obj_2() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_proceduresContext is an interface to support dynamic dispatch. +type IShow_proceduresContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + PROCEDURES() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_proceduresContext differentiates from other interfaces. + IsShow_proceduresContext() +} + +type Show_proceduresContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_proceduresContext() *Show_proceduresContext { + var p = new(Show_proceduresContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_procedures + return p +} + +func InitEmptyShow_proceduresContext(p *Show_proceduresContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_procedures +} + +func (*Show_proceduresContext) IsShow_proceduresContext() {} + +func NewShow_proceduresContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_proceduresContext { + var p = new(Show_proceduresContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_procedures + + return p +} + +func (s *Show_proceduresContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_proceduresContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_proceduresContext) PROCEDURES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURES, 0) +} + +func (s *Show_proceduresContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_proceduresContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_proceduresContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_proceduresContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_proceduresContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_procedures(s) + } +} + +func (s *Show_proceduresContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_procedures(s) + } +} + +func (s *Show_proceduresContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_procedures(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_procedures() (localctx IShow_proceduresContext) { + localctx = NewShow_proceduresContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 780, SnowflakeParserRULE_show_procedures) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10189) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10190) + p.Match(SnowflakeParserPROCEDURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10191) + p.Like_pattern() + } + + } + p.SetState(10195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10194) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_regionsContext is an interface to support dynamic dispatch. +type IShow_regionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + REGIONS() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_regionsContext differentiates from other interfaces. + IsShow_regionsContext() +} + +type Show_regionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_regionsContext() *Show_regionsContext { + var p = new(Show_regionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_regions + return p +} + +func InitEmptyShow_regionsContext(p *Show_regionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_regions +} + +func (*Show_regionsContext) IsShow_regionsContext() {} + +func NewShow_regionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_regionsContext { + var p = new(Show_regionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_regions + + return p +} + +func (s *Show_regionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_regionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_regionsContext) REGIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREGIONS, 0) +} + +func (s *Show_regionsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_regionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_regionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_regionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_regions(s) + } +} + +func (s *Show_regionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_regions(s) + } +} + +func (s *Show_regionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_regions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_regions() (localctx IShow_regionsContext) { + localctx = NewShow_regionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 782, SnowflakeParserRULE_show_regions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10197) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10198) + p.Match(SnowflakeParserREGIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10199) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_replication_accountsContext is an interface to support dynamic dispatch. +type IShow_replication_accountsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + ACCOUNTS() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_replication_accountsContext differentiates from other interfaces. + IsShow_replication_accountsContext() +} + +type Show_replication_accountsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_replication_accountsContext() *Show_replication_accountsContext { + var p = new(Show_replication_accountsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_replication_accounts + return p +} + +func InitEmptyShow_replication_accountsContext(p *Show_replication_accountsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_replication_accounts +} + +func (*Show_replication_accountsContext) IsShow_replication_accountsContext() {} + +func NewShow_replication_accountsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_replication_accountsContext { + var p = new(Show_replication_accountsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_replication_accounts + + return p +} + +func (s *Show_replication_accountsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_replication_accountsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_replication_accountsContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Show_replication_accountsContext) ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTS, 0) +} + +func (s *Show_replication_accountsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_replication_accountsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_replication_accountsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_replication_accountsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_replication_accounts(s) + } +} + +func (s *Show_replication_accountsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_replication_accounts(s) + } +} + +func (s *Show_replication_accountsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_replication_accounts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_replication_accounts() (localctx IShow_replication_accountsContext) { + localctx = NewShow_replication_accountsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 784, SnowflakeParserRULE_show_replication_accounts) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10202) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10203) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10204) + p.Match(SnowflakeParserACCOUNTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10205) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_replication_databasesContext is an interface to support dynamic dispatch. +type IShow_replication_databasesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + DATABASES() antlr.TerminalNode + Like_pattern() ILike_patternContext + WITH() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + Account_identifier() IAccount_identifierContext + DOT() antlr.TerminalNode + Id_() IId_Context + + // IsShow_replication_databasesContext differentiates from other interfaces. + IsShow_replication_databasesContext() +} + +type Show_replication_databasesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_replication_databasesContext() *Show_replication_databasesContext { + var p = new(Show_replication_databasesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_replication_databases + return p +} + +func InitEmptyShow_replication_databasesContext(p *Show_replication_databasesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_replication_databases +} + +func (*Show_replication_databasesContext) IsShow_replication_databasesContext() {} + +func NewShow_replication_databasesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_replication_databasesContext { + var p = new(Show_replication_databasesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_replication_databases + + return p +} + +func (s *Show_replication_databasesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_replication_databasesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_replication_databasesContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Show_replication_databasesContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Show_replication_databasesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_replication_databasesContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Show_replication_databasesContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Show_replication_databasesContext) Account_identifier() IAccount_identifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccount_identifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccount_identifierContext) +} + +func (s *Show_replication_databasesContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *Show_replication_databasesContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_replication_databasesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_replication_databasesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_replication_databasesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_replication_databases(s) + } +} + +func (s *Show_replication_databasesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_replication_databases(s) + } +} + +func (s *Show_replication_databasesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_replication_databases(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_replication_databases() (localctx IShow_replication_databasesContext) { + localctx = NewShow_replication_databasesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 786, SnowflakeParserRULE_show_replication_databases) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10208) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10209) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10210) + p.Match(SnowflakeParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10211) + p.Like_pattern() + } + + } + p.SetState(10220) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(10214) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10215) + p.Match(SnowflakeParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10216) + p.Account_identifier() + } + { + p.SetState(10217) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10218) + p.Id_() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_replication_groupsContext is an interface to support dynamic dispatch. +type IShow_replication_groupsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + GROUPS() antlr.TerminalNode + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + Id_() IId_Context + + // IsShow_replication_groupsContext differentiates from other interfaces. + IsShow_replication_groupsContext() +} + +type Show_replication_groupsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_replication_groupsContext() *Show_replication_groupsContext { + var p = new(Show_replication_groupsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_replication_groups + return p +} + +func InitEmptyShow_replication_groupsContext(p *Show_replication_groupsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_replication_groups +} + +func (*Show_replication_groupsContext) IsShow_replication_groupsContext() {} + +func NewShow_replication_groupsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_replication_groupsContext { + var p = new(Show_replication_groupsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_replication_groups + + return p +} + +func (s *Show_replication_groupsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_replication_groupsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_replication_groupsContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Show_replication_groupsContext) GROUPS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUPS, 0) +} + +func (s *Show_replication_groupsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_replication_groupsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_replication_groupsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_replication_groupsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_replication_groupsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_replication_groupsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_replication_groups(s) + } +} + +func (s *Show_replication_groupsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_replication_groups(s) + } +} + +func (s *Show_replication_groupsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_replication_groups(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_replication_groups() (localctx IShow_replication_groupsContext) { + localctx = NewShow_replication_groupsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 788, SnowflakeParserRULE_show_replication_groups) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10222) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10223) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10224) + p.Match(SnowflakeParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10225) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10226) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10227) + p.Id_() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_resource_monitorsContext is an interface to support dynamic dispatch. +type IShow_resource_monitorsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + MONITORS() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_resource_monitorsContext differentiates from other interfaces. + IsShow_resource_monitorsContext() +} + +type Show_resource_monitorsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_resource_monitorsContext() *Show_resource_monitorsContext { + var p = new(Show_resource_monitorsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_resource_monitors + return p +} + +func InitEmptyShow_resource_monitorsContext(p *Show_resource_monitorsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_resource_monitors +} + +func (*Show_resource_monitorsContext) IsShow_resource_monitorsContext() {} + +func NewShow_resource_monitorsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_resource_monitorsContext { + var p = new(Show_resource_monitorsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_resource_monitors + + return p +} + +func (s *Show_resource_monitorsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_resource_monitorsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_resource_monitorsContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE, 0) +} + +func (s *Show_resource_monitorsContext) MONITORS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITORS, 0) +} + +func (s *Show_resource_monitorsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_resource_monitorsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_resource_monitorsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_resource_monitorsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_resource_monitors(s) + } +} + +func (s *Show_resource_monitorsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_resource_monitors(s) + } +} + +func (s *Show_resource_monitorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_resource_monitors(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_resource_monitors() (localctx IShow_resource_monitorsContext) { + localctx = NewShow_resource_monitorsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 790, SnowflakeParserRULE_show_resource_monitors) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10230) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10231) + p.Match(SnowflakeParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10232) + p.Match(SnowflakeParserMONITORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10233) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_rolesContext is an interface to support dynamic dispatch. +type IShow_rolesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + ROLES() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_rolesContext differentiates from other interfaces. + IsShow_rolesContext() +} + +type Show_rolesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_rolesContext() *Show_rolesContext { + var p = new(Show_rolesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_roles + return p +} + +func InitEmptyShow_rolesContext(p *Show_rolesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_roles +} + +func (*Show_rolesContext) IsShow_rolesContext() {} + +func NewShow_rolesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_rolesContext { + var p = new(Show_rolesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_roles + + return p +} + +func (s *Show_rolesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_rolesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_rolesContext) ROLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLES, 0) +} + +func (s *Show_rolesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_rolesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_rolesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_rolesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_roles(s) + } +} + +func (s *Show_rolesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_roles(s) + } +} + +func (s *Show_rolesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_roles(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_roles() (localctx IShow_rolesContext) { + localctx = NewShow_rolesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 792, SnowflakeParserRULE_show_roles) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10236) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10237) + p.Match(SnowflakeParserROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10238) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_row_access_policiesContext is an interface to support dynamic dispatch. +type IShow_row_access_policiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + ROW() antlr.TerminalNode + ACCESS() antlr.TerminalNode + POLICIES() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_row_access_policiesContext differentiates from other interfaces. + IsShow_row_access_policiesContext() +} + +type Show_row_access_policiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_row_access_policiesContext() *Show_row_access_policiesContext { + var p = new(Show_row_access_policiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_row_access_policies + return p +} + +func InitEmptyShow_row_access_policiesContext(p *Show_row_access_policiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_row_access_policies +} + +func (*Show_row_access_policiesContext) IsShow_row_access_policiesContext() {} + +func NewShow_row_access_policiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_row_access_policiesContext { + var p = new(Show_row_access_policiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_row_access_policies + + return p +} + +func (s *Show_row_access_policiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_row_access_policiesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_row_access_policiesContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Show_row_access_policiesContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Show_row_access_policiesContext) POLICIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICIES, 0) +} + +func (s *Show_row_access_policiesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_row_access_policiesContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_row_access_policiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_row_access_policiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_row_access_policiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_row_access_policies(s) + } +} + +func (s *Show_row_access_policiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_row_access_policies(s) + } +} + +func (s *Show_row_access_policiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_row_access_policies(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_row_access_policies() (localctx IShow_row_access_policiesContext) { + localctx = NewShow_row_access_policiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 794, SnowflakeParserRULE_show_row_access_policies) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10241) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10242) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10243) + p.Match(SnowflakeParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10244) + p.Match(SnowflakeParserPOLICIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10245) + p.Like_pattern() + } + + } + p.SetState(10249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10248) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_schemasContext is an interface to support dynamic dispatch. +type IShow_schemasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + TERSE() antlr.TerminalNode + HISTORY() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + Starts_with() IStarts_withContext + Limit_rows() ILimit_rowsContext + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + + // IsShow_schemasContext differentiates from other interfaces. + IsShow_schemasContext() +} + +type Show_schemasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_schemasContext() *Show_schemasContext { + var p = new(Show_schemasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_schemas + return p +} + +func InitEmptyShow_schemasContext(p *Show_schemasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_schemas +} + +func (*Show_schemasContext) IsShow_schemasContext() {} + +func NewShow_schemasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_schemasContext { + var p = new(Show_schemasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_schemas + + return p +} + +func (s *Show_schemasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_schemasContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_schemasContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMAS, 0) +} + +func (s *Show_schemasContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Show_schemasContext) HISTORY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHISTORY, 0) +} + +func (s *Show_schemasContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_schemasContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_schemasContext) Starts_with() IStarts_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStarts_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStarts_withContext) +} + +func (s *Show_schemasContext) Limit_rows() ILimit_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_rowsContext) +} + +func (s *Show_schemasContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_schemasContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_schemasContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_schemasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_schemasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_schemasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_schemas(s) + } +} + +func (s *Show_schemasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_schemas(s) + } +} + +func (s *Show_schemasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_schemas(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_schemas() (localctx IShow_schemasContext) { + localctx = NewShow_schemasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 796, SnowflakeParserRULE_show_schemas) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10251) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTERSE { + { + p.SetState(10252) + p.Match(SnowflakeParserTERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10255) + p.Match(SnowflakeParserSCHEMAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserHISTORY { + { + p.SetState(10256) + p.Match(SnowflakeParserHISTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10259) + p.Like_pattern() + } + + } + p.SetState(10270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10262) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT: + { + p.SetState(10263) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(10264) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10266) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1306, p.GetParserRuleContext()) == 1 { + { + p.SetState(10265) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(10273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTARTS { + { + p.SetState(10272) + p.Starts_with() + } + + } + p.SetState(10276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIMIT { + { + p.SetState(10275) + p.Limit_rows() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_sequencesContext is an interface to support dynamic dispatch. +type IShow_sequencesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + SEQUENCES() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_sequencesContext differentiates from other interfaces. + IsShow_sequencesContext() +} + +type Show_sequencesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_sequencesContext() *Show_sequencesContext { + var p = new(Show_sequencesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_sequences + return p +} + +func InitEmptyShow_sequencesContext(p *Show_sequencesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_sequences +} + +func (*Show_sequencesContext) IsShow_sequencesContext() {} + +func NewShow_sequencesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_sequencesContext { + var p = new(Show_sequencesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_sequences + + return p +} + +func (s *Show_sequencesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_sequencesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_sequencesContext) SEQUENCES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCES, 0) +} + +func (s *Show_sequencesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_sequencesContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_sequencesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_sequencesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_sequencesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_sequences(s) + } +} + +func (s *Show_sequencesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_sequences(s) + } +} + +func (s *Show_sequencesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_sequences(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_sequences() (localctx IShow_sequencesContext) { + localctx = NewShow_sequencesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 798, SnowflakeParserRULE_show_sequences) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10278) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10279) + p.Match(SnowflakeParserSEQUENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10280) + p.Like_pattern() + } + + } + p.SetState(10284) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10283) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_session_policiesContext is an interface to support dynamic dispatch. +type IShow_session_policiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + SESSION() antlr.TerminalNode + POLICIES() antlr.TerminalNode + + // IsShow_session_policiesContext differentiates from other interfaces. + IsShow_session_policiesContext() +} + +type Show_session_policiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_session_policiesContext() *Show_session_policiesContext { + var p = new(Show_session_policiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_session_policies + return p +} + +func InitEmptyShow_session_policiesContext(p *Show_session_policiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_session_policies +} + +func (*Show_session_policiesContext) IsShow_session_policiesContext() {} + +func NewShow_session_policiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_session_policiesContext { + var p = new(Show_session_policiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_session_policies + + return p +} + +func (s *Show_session_policiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_session_policiesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_session_policiesContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Show_session_policiesContext) POLICIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICIES, 0) +} + +func (s *Show_session_policiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_session_policiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_session_policiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_session_policies(s) + } +} + +func (s *Show_session_policiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_session_policies(s) + } +} + +func (s *Show_session_policiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_session_policies(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_session_policies() (localctx IShow_session_policiesContext) { + localctx = NewShow_session_policiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 800, SnowflakeParserRULE_show_session_policies) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10286) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10287) + p.Match(SnowflakeParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10288) + p.Match(SnowflakeParserPOLICIES) + 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 +} + +// IShow_sharesContext is an interface to support dynamic dispatch. +type IShow_sharesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + SHARES() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_sharesContext differentiates from other interfaces. + IsShow_sharesContext() +} + +type Show_sharesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_sharesContext() *Show_sharesContext { + var p = new(Show_sharesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_shares + return p +} + +func InitEmptyShow_sharesContext(p *Show_sharesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_shares +} + +func (*Show_sharesContext) IsShow_sharesContext() {} + +func NewShow_sharesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_sharesContext { + var p = new(Show_sharesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_shares + + return p +} + +func (s *Show_sharesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_sharesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_sharesContext) SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARES, 0) +} + +func (s *Show_sharesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_sharesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_sharesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_sharesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_shares(s) + } +} + +func (s *Show_sharesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_shares(s) + } +} + +func (s *Show_sharesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_shares(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_shares() (localctx IShow_sharesContext) { + localctx = NewShow_sharesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 802, SnowflakeParserRULE_show_shares) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10290) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10291) + p.Match(SnowflakeParserSHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10292) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_shares_in_failover_groupContext is an interface to support dynamic dispatch. +type IShow_shares_in_failover_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + SHARES() antlr.TerminalNode + IN() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + + // IsShow_shares_in_failover_groupContext differentiates from other interfaces. + IsShow_shares_in_failover_groupContext() +} + +type Show_shares_in_failover_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_shares_in_failover_groupContext() *Show_shares_in_failover_groupContext { + var p = new(Show_shares_in_failover_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_shares_in_failover_group + return p +} + +func InitEmptyShow_shares_in_failover_groupContext(p *Show_shares_in_failover_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_shares_in_failover_group +} + +func (*Show_shares_in_failover_groupContext) IsShow_shares_in_failover_groupContext() {} + +func NewShow_shares_in_failover_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_shares_in_failover_groupContext { + var p = new(Show_shares_in_failover_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_shares_in_failover_group + + return p +} + +func (s *Show_shares_in_failover_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_shares_in_failover_groupContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_shares_in_failover_groupContext) SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARES, 0) +} + +func (s *Show_shares_in_failover_groupContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_shares_in_failover_groupContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, 0) +} + +func (s *Show_shares_in_failover_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Show_shares_in_failover_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_shares_in_failover_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_shares_in_failover_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_shares_in_failover_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_shares_in_failover_group(s) + } +} + +func (s *Show_shares_in_failover_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_shares_in_failover_group(s) + } +} + +func (s *Show_shares_in_failover_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_shares_in_failover_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_shares_in_failover_group() (localctx IShow_shares_in_failover_groupContext) { + localctx = NewShow_shares_in_failover_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 804, SnowflakeParserRULE_show_shares_in_failover_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10295) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10296) + p.Match(SnowflakeParserSHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10297) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10298) + p.Match(SnowflakeParserFAILOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10299) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10300) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_shares_in_replication_groupContext is an interface to support dynamic dispatch. +type IShow_shares_in_replication_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + SHARES() antlr.TerminalNode + IN() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_() IId_Context + + // IsShow_shares_in_replication_groupContext differentiates from other interfaces. + IsShow_shares_in_replication_groupContext() +} + +type Show_shares_in_replication_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_shares_in_replication_groupContext() *Show_shares_in_replication_groupContext { + var p = new(Show_shares_in_replication_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_shares_in_replication_group + return p +} + +func InitEmptyShow_shares_in_replication_groupContext(p *Show_shares_in_replication_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_shares_in_replication_group +} + +func (*Show_shares_in_replication_groupContext) IsShow_shares_in_replication_groupContext() {} + +func NewShow_shares_in_replication_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_shares_in_replication_groupContext { + var p = new(Show_shares_in_replication_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_shares_in_replication_group + + return p +} + +func (s *Show_shares_in_replication_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_shares_in_replication_groupContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_shares_in_replication_groupContext) SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARES, 0) +} + +func (s *Show_shares_in_replication_groupContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_shares_in_replication_groupContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Show_shares_in_replication_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Show_shares_in_replication_groupContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_shares_in_replication_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_shares_in_replication_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_shares_in_replication_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_shares_in_replication_group(s) + } +} + +func (s *Show_shares_in_replication_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_shares_in_replication_group(s) + } +} + +func (s *Show_shares_in_replication_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_shares_in_replication_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_shares_in_replication_group() (localctx IShow_shares_in_replication_groupContext) { + localctx = NewShow_shares_in_replication_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 806, SnowflakeParserRULE_show_shares_in_replication_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10302) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10303) + p.Match(SnowflakeParserSHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10304) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10305) + p.Match(SnowflakeParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10306) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10307) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_stagesContext is an interface to support dynamic dispatch. +type IShow_stagesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + STAGES() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_stagesContext differentiates from other interfaces. + IsShow_stagesContext() +} + +type Show_stagesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_stagesContext() *Show_stagesContext { + var p = new(Show_stagesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_stages + return p +} + +func InitEmptyShow_stagesContext(p *Show_stagesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_stages +} + +func (*Show_stagesContext) IsShow_stagesContext() {} + +func NewShow_stagesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_stagesContext { + var p = new(Show_stagesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_stages + + return p +} + +func (s *Show_stagesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_stagesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_stagesContext) STAGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGES, 0) +} + +func (s *Show_stagesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_stagesContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_stagesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_stagesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_stagesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_stages(s) + } +} + +func (s *Show_stagesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_stages(s) + } +} + +func (s *Show_stagesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_stages(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_stages() (localctx IShow_stagesContext) { + localctx = NewShow_stagesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 808, SnowflakeParserRULE_show_stages) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10309) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10310) + p.Match(SnowflakeParserSTAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10311) + p.Like_pattern() + } + + } + p.SetState(10315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10314) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_streamsContext is an interface to support dynamic dispatch. +type IShow_streamsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + STREAMS() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_streamsContext differentiates from other interfaces. + IsShow_streamsContext() +} + +type Show_streamsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_streamsContext() *Show_streamsContext { + var p = new(Show_streamsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_streams + return p +} + +func InitEmptyShow_streamsContext(p *Show_streamsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_streams +} + +func (*Show_streamsContext) IsShow_streamsContext() {} + +func NewShow_streamsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_streamsContext { + var p = new(Show_streamsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_streams + + return p +} + +func (s *Show_streamsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_streamsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_streamsContext) STREAMS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAMS, 0) +} + +func (s *Show_streamsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_streamsContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_streamsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_streamsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_streamsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_streams(s) + } +} + +func (s *Show_streamsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_streams(s) + } +} + +func (s *Show_streamsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_streams(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_streams() (localctx IShow_streamsContext) { + localctx = NewShow_streamsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 810, SnowflakeParserRULE_show_streams) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10317) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10318) + p.Match(SnowflakeParserSTREAMS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10319) + p.Like_pattern() + } + + } + p.SetState(10323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10322) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_tablesContext is an interface to support dynamic dispatch. +type IShow_tablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + TABLES() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_tablesContext differentiates from other interfaces. + IsShow_tablesContext() +} + +type Show_tablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_tablesContext() *Show_tablesContext { + var p = new(Show_tablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_tables + return p +} + +func InitEmptyShow_tablesContext(p *Show_tablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_tables +} + +func (*Show_tablesContext) IsShow_tablesContext() {} + +func NewShow_tablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_tablesContext { + var p = new(Show_tablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_tables + + return p +} + +func (s *Show_tablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_tablesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_tablesContext) TABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLES, 0) +} + +func (s *Show_tablesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_tablesContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_tablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_tablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_tablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_tables(s) + } +} + +func (s *Show_tablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_tables(s) + } +} + +func (s *Show_tablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_tables(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_tables() (localctx IShow_tablesContext) { + localctx = NewShow_tablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 812, SnowflakeParserRULE_show_tables) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10325) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10326) + p.Match(SnowflakeParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10327) + p.Like_pattern() + } + + } + p.SetState(10331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10330) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_tagsContext is an interface to support dynamic dispatch. +type IShow_tagsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + TAGS() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsShow_tagsContext differentiates from other interfaces. + IsShow_tagsContext() +} + +type Show_tagsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_tagsContext() *Show_tagsContext { + var p = new(Show_tagsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_tags + return p +} + +func InitEmptyShow_tagsContext(p *Show_tagsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_tags +} + +func (*Show_tagsContext) IsShow_tagsContext() {} + +func NewShow_tagsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_tagsContext { + var p = new(Show_tagsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_tags + + return p +} + +func (s *Show_tagsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_tagsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_tagsContext) TAGS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAGS, 0) +} + +func (s *Show_tagsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_tagsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_tagsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_tagsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_tagsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_tagsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_tagsContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_tagsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_tagsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_tagsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_tags(s) + } +} + +func (s *Show_tagsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_tags(s) + } +} + +func (s *Show_tagsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_tags(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_tags() (localctx IShow_tagsContext) { + localctx = NewShow_tagsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 814, SnowflakeParserRULE_show_tags) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10333) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10334) + p.Match(SnowflakeParserTAGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10336) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10335) + p.Like_pattern() + } + + } + p.SetState(10347) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1321, p.GetParserRuleContext()) == 1 { + { + p.SetState(10338) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10339) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1321, p.GetParserRuleContext()) == 2 { + { + p.SetState(10340) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1321, p.GetParserRuleContext()) == 3 { + { + p.SetState(10341) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10342) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1321, p.GetParserRuleContext()) == 4 { + { + p.SetState(10343) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1321, p.GetParserRuleContext()) == 5 { + { + p.SetState(10344) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10345) + p.Schema_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1321, p.GetParserRuleContext()) == 6 { + { + p.SetState(10346) + p.Schema_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 +} + +// IShow_tasksContext is an interface to support dynamic dispatch. +type IShow_tasksContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + TASKS() antlr.TerminalNode + TERSE() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + Starts_with() IStarts_withContext + Limit_rows() ILimit_rowsContext + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsShow_tasksContext differentiates from other interfaces. + IsShow_tasksContext() +} + +type Show_tasksContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_tasksContext() *Show_tasksContext { + var p = new(Show_tasksContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_tasks + return p +} + +func InitEmptyShow_tasksContext(p *Show_tasksContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_tasks +} + +func (*Show_tasksContext) IsShow_tasksContext() {} + +func NewShow_tasksContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_tasksContext { + var p = new(Show_tasksContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_tasks + + return p +} + +func (s *Show_tasksContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_tasksContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_tasksContext) TASKS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASKS, 0) +} + +func (s *Show_tasksContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Show_tasksContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_tasksContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_tasksContext) Starts_with() IStarts_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStarts_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStarts_withContext) +} + +func (s *Show_tasksContext) Limit_rows() ILimit_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_rowsContext) +} + +func (s *Show_tasksContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_tasksContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_tasksContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_tasksContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_tasksContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_tasksContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_tasksContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_tasksContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_tasks(s) + } +} + +func (s *Show_tasksContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_tasks(s) + } +} + +func (s *Show_tasksContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_tasks(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_tasks() (localctx IShow_tasksContext) { + localctx = NewShow_tasksContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 816, SnowflakeParserRULE_show_tasks) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10349) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTERSE { + { + p.SetState(10350) + p.Match(SnowflakeParserTERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10353) + p.Match(SnowflakeParserTASKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10354) + p.Like_pattern() + } + + } + p.SetState(10371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10357) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT: + { + p.SetState(10358) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(10359) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10361) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1324, p.GetParserRuleContext()) == 1 { + { + p.SetState(10360) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserEOF, SnowflakeParserAAD_PROVISIONER_Q, SnowflakeParserABORT, SnowflakeParserABORT_AFTER_WAIT, SnowflakeParserABORT_DETACHED_QUERY, SnowflakeParserABORT_STATEMENT, SnowflakeParserABSENT, SnowflakeParserABSOLUTE, SnowflakeParserACCESS, SnowflakeParserACCOUNTADMIN, SnowflakeParserACCOUNTS, SnowflakeParserACTION, SnowflakeParserACTIVE, SnowflakeParserADD, SnowflakeParserADMINISTER, SnowflakeParserADMIN_NAME, SnowflakeParserADMIN_PASSWORD, SnowflakeParserAES, SnowflakeParserAFTER, SnowflakeParserAGGREGATE, SnowflakeParserALERT, SnowflakeParserALERTS, SnowflakeParserALLOWED, SnowflakeParserALLOWED_ACCOUNTS, SnowflakeParserALLOWED_DATABASES, SnowflakeParserALLOWED_INTEGRATION_TYPES, SnowflakeParserALLOWED_IP_LIST, SnowflakeParserALLOWED_SHARES, SnowflakeParserALLOWED_VALUES, SnowflakeParserALLOW_CLIENT_MFA_CACHING, SnowflakeParserALLOW_CONNECTIONS, SnowflakeParserALLOW_DUPLICATE, SnowflakeParserALLOW_ID_TOKEN, SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, SnowflakeParserALLOW_OVERLAPPING_EXECUTION, SnowflakeParserALLOW_SINGLE_EVENT_LOSS, SnowflakeParserALWAYS, SnowflakeParserANONYMOUS, SnowflakeParserANSI_DEFAULTS, SnowflakeParserAPI, SnowflakeParserAPI_ALLOWED_PREFIXES, SnowflakeParserAPI_AWS_ROLE_ARN, SnowflakeParserAPI_BLOCKED_PREFIXES, SnowflakeParserAPI_INTEGRATION, SnowflakeParserAPI_KEY, SnowflakeParserAPI_PROVIDER, SnowflakeParserAPPEND, SnowflakeParserAPPEND_ONLY, SnowflakeParserAPPLICATION, SnowflakeParserAPPLY, SnowflakeParserAPP_NAME, SnowflakeParserASC, SnowflakeParserATTACH, SnowflakeParserAT_KEYWORD, SnowflakeParserAUTHORIZATION, SnowflakeParserAUTHORIZATIONS, SnowflakeParserAUTO, SnowflakeParserAUTO_Q, SnowflakeParserAUTOCOMMIT, SnowflakeParserAUTOCOMMIT_API_SUPPORTED, SnowflakeParserAUTOINCREMENT, SnowflakeParserAUTO_COMPRESS, SnowflakeParserAUTO_DETECT, SnowflakeParserAUTO_INGEST, SnowflakeParserAUTO_REFRESH, SnowflakeParserAUTO_RESUME, SnowflakeParserAUTO_SUSPEND, SnowflakeParserAVG, SnowflakeParserAVRO, SnowflakeParserAVRO_Q, SnowflakeParserAWS_KEY_ID, SnowflakeParserAWS_ROLE, SnowflakeParserAWS_SECRET_KEY, SnowflakeParserAWS_SNS, SnowflakeParserAWS_SNS_ROLE_ARN, SnowflakeParserAWS_SNS_TOPIC, SnowflakeParserAWS_SNS_TOPIC_ARN, SnowflakeParserAWS_TOKEN, SnowflakeParserAZURE, SnowflakeParserAZURE_AD_APPLICATION_ID, SnowflakeParserAZURE_EVENT_GRID, SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, SnowflakeParserAZURE_Q, SnowflakeParserAZURE_SAS_TOKEN, SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, SnowflakeParserAZURE_TENANT_ID, SnowflakeParserBEFORE, SnowflakeParserBEGIN, SnowflakeParserBERNOULLI, SnowflakeParserBINARY_AS_TEXT, SnowflakeParserBINARY_CHECKSUM, SnowflakeParserBINARY_FORMAT, SnowflakeParserBINARY_INPUT_FORMAT, SnowflakeParserBINARY_OUTPUT_FORMAT, SnowflakeParserBINDING, SnowflakeParserBLOCK, SnowflakeParserBLOCKED_IP_LIST, SnowflakeParserBLOCKED_ROLES_LIST, SnowflakeParserBODY, SnowflakeParserBOTH_Q, SnowflakeParserBROTLI, SnowflakeParserBUSINESS_CRITICAL, SnowflakeParserCACHE, SnowflakeParserCALL, SnowflakeParserCALLED, SnowflakeParserCALLER, SnowflakeParserCASCADE, SnowflakeParserCASE_INSENSITIVE, SnowflakeParserCASE_SENSITIVE, SnowflakeParserCATCH, SnowflakeParserCERTIFICATE, SnowflakeParserCHANGE, SnowflakeParserCHANGES, SnowflakeParserCHANGETABLE, SnowflakeParserCHANGE_RETENTION, SnowflakeParserCHANGE_TRACKING, SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserCHARINDEX, SnowflakeParserCHECKSUM, SnowflakeParserCHECKSUM_AGG, SnowflakeParserCHECK_EXPIRATION, SnowflakeParserCHECK_POLICY, SnowflakeParserCLASSIFIER_FUNCTION, SnowflakeParserCLEANUP, SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, SnowflakeParserCLIENT_MEMORY_LIMIT, SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, SnowflakeParserCLIENT_PREFETCH_THREADS, SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, SnowflakeParserCLONE, SnowflakeParserCLOSE, SnowflakeParserCLUSTER, SnowflakeParserCLUSTERED, SnowflakeParserCLUSTERING, SnowflakeParserCOALESCE, SnowflakeParserCOLLATE, SnowflakeParserCOLLECTION, SnowflakeParserCOLUMNS, SnowflakeParserCOL_LENGTH, SnowflakeParserCOL_NAME, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOMMITTED, SnowflakeParserCOMPRESS, SnowflakeParserCOMPRESSION, SnowflakeParserCONCAT, SnowflakeParserCONCAT_NULL_YIELDS_NULL, SnowflakeParserCONCAT_WS, SnowflakeParserCONDITION, SnowflakeParserCONFIGURATION, SnowflakeParserCONNECTIONS, SnowflakeParserCONTAINMENT, SnowflakeParserCONTAINS, SnowflakeParserCONTENT, SnowflakeParserCONTEXT, SnowflakeParserCONTEXT_HEADERS, SnowflakeParserCONTEXT_INFO, SnowflakeParserCONTINUE, SnowflakeParserCONTROL, SnowflakeParserCONVERSATION, SnowflakeParserCOOKIE, SnowflakeParserCOPY, SnowflakeParserCOPY_ONLY, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserCOUNT, SnowflakeParserCOUNT_BIG, SnowflakeParserCREDENTIALS, SnowflakeParserCREDIT_QUOTA, SnowflakeParserCSV, SnowflakeParserCSV_Q, SnowflakeParserCUBE, SnowflakeParserCUME_DIST, SnowflakeParserCURRENT_DATE, SnowflakeParserCURRENT_TIMESTAMP, SnowflakeParserCURSOR, SnowflakeParserCUSTOM, SnowflakeParserDAILY, SnowflakeParserDATA, SnowflakeParserDATABASES, SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, SnowflakeParserDATEADD, SnowflakeParserDATEDIFF, SnowflakeParserDATENAME, SnowflakeParserDATEPART, SnowflakeParserDATE_FORMAT, SnowflakeParserDATE_INPUT_FORMAT, SnowflakeParserDATE_OUTPUT_FORMAT, SnowflakeParserDATE_PART, SnowflakeParserDAYS, SnowflakeParserDAYS_TO_EXPIRY, SnowflakeParserDECLARE, SnowflakeParserDEFAULT, SnowflakeParserDEFAULT_DDL_COLLATION_, SnowflakeParserDEFAULT_NAMESPACE, SnowflakeParserDEFAULT_ROLE, SnowflakeParserDEFAULT_WAREHOUSE, SnowflakeParserDEFERRABLE, SnowflakeParserDEFERRED, SnowflakeParserDEFINE, SnowflakeParserDEFINITION, SnowflakeParserDEFLATE, SnowflakeParserDELEGATED, SnowflakeParserDELTA, SnowflakeParserDENSE_RANK, SnowflakeParserDESC, SnowflakeParserDESCRIBE, SnowflakeParserDIRECTION, SnowflakeParserDIRECTORY, SnowflakeParserDISABLE, SnowflakeParserDISABLED, SnowflakeParserDISABLE_AUTO_CONVERT, SnowflakeParserDISABLE_SNOWFLAKE_DATA, SnowflakeParserDISK, SnowflakeParserDISPLAY_NAME, SnowflakeParserDO, SnowflakeParserDOWNSTREAM, SnowflakeParserDOUBLE, SnowflakeParserDYNAMIC, SnowflakeParserECONOMY, SnowflakeParserEDITION, SnowflakeParserEMAIL, SnowflakeParserEMPTY_, SnowflakeParserEMPTY_FIELD_AS_NULL, SnowflakeParserENABLE, SnowflakeParserENABLED, SnowflakeParserENABLE_FOR_PRIVILEGE, SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, SnowflakeParserENABLE_OCTAL, SnowflakeParserENABLE_QUERY_ACCELERATION, SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, SnowflakeParserENCODING, SnowflakeParserENCRYPTION, SnowflakeParserEND, SnowflakeParserENDPOINT, SnowflakeParserEND_TIMESTAMP, SnowflakeParserENFORCED, SnowflakeParserENFORCE_LENGTH, SnowflakeParserENFORCE_SESSION_POLICY, SnowflakeParserENTERPRISE, SnowflakeParserEQUALITY, SnowflakeParserERROR_INTEGRATION, SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, SnowflakeParserESCAPE, SnowflakeParserESCAPE_UNENCLOSED_FIELD, SnowflakeParserEXCEPT, SnowflakeParserEXCHANGE, SnowflakeParserEXECUTE, SnowflakeParserEXECUTION, SnowflakeParserEXIST, SnowflakeParserEXIT, SnowflakeParserEXPAND, SnowflakeParserEXPIRY_DATE, SnowflakeParserEXPLAIN, SnowflakeParserEXPLICIT, SnowflakeParserEXTERNAL, SnowflakeParserEXTERNAL_OAUTH, SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ISSUER, SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, SnowflakeParserEXTERNAL_OAUTH_TYPE, SnowflakeParserEXTERNAL_STAGE, SnowflakeParserFAILOVER, SnowflakeParserFAILOVER_MODE, SnowflakeParserFAIL_OPERATION, SnowflakeParserFETCH, SnowflakeParserFIELD_DELIMITER, SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, SnowflakeParserFILE, SnowflakeParserFILES, SnowflakeParserFILE_EXTENSION, SnowflakeParserFILE_FORMAT, SnowflakeParserFILTER, SnowflakeParserFIRST, SnowflakeParserFIRST_NAME, SnowflakeParserFLATTEN, SnowflakeParserFORCE, SnowflakeParserFOREIGN, SnowflakeParserFORMAT, SnowflakeParserFORMATS, SnowflakeParserFORMAT_NAME, SnowflakeParserFREQUENCY, SnowflakeParserFUNCTION, SnowflakeParserFUNCTIONS, SnowflakeParserFUTURE, SnowflakeParserGCP_PUBSUB, SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, SnowflakeParserGCP_PUBSUB_TOPIC_NAME, SnowflakeParserGCS, SnowflakeParserGENERIC_Q, SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, SnowflakeParserGEO, SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, SnowflakeParserGEOMETRY_OUTPUT_FORMAT, SnowflakeParserGET, SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, SnowflakeParserGLOBAL, SnowflakeParserGOOGLE_AUDIENCE, SnowflakeParserGOTO, SnowflakeParserGRANTS, SnowflakeParserGROUPING, SnowflakeParserGROUPING_ID, SnowflakeParserGROUPS, SnowflakeParserGZIP, SnowflakeParserHEADER, SnowflakeParserHEADERS, SnowflakeParserHEX, SnowflakeParserHIERARCHYID, SnowflakeParserHIGH, SnowflakeParserHISTORY, SnowflakeParserHOURS, SnowflakeParserIDENTITY, SnowflakeParserIF, SnowflakeParserIFF, SnowflakeParserIFNULL, SnowflakeParserIGNORE, SnowflakeParserIGNORE_CONSTRAINTS, SnowflakeParserIGNORE_DUP_KEY, SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, SnowflakeParserIGNORE_TRIGGERS, SnowflakeParserIMMEDIATE, SnowflakeParserIMMEDIATELY, SnowflakeParserIMMUTABLE, SnowflakeParserIMPLICIT, SnowflakeParserIMPORT, SnowflakeParserIMPORTED, SnowflakeParserINDEX, SnowflakeParserINFORMATION, SnowflakeParserINIT, SnowflakeParserINITIALLY, SnowflakeParserINITIALLY_SUSPENDED, SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, SnowflakeParserINPUT, SnowflakeParserINSERT_ONLY, SnowflakeParserINSTEAD, SnowflakeParserINT, SnowflakeParserINTEGRATION, SnowflakeParserINTEGRATIONS, SnowflakeParserISNULL, SnowflakeParserISNUMERIC, SnowflakeParserISOLATION, SnowflakeParserJAVASCRIPT, SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, SnowflakeParserJDBC_USE_SESSION_TIMEZONE, SnowflakeParserJSON, SnowflakeParserJSON_Q, SnowflakeParserJSON_INDENT, SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, SnowflakeParserKB, SnowflakeParserKEEP, SnowflakeParserKEY, SnowflakeParserKEYS, SnowflakeParserKEYSET, SnowflakeParserKMS_KEY_ID, SnowflakeParserLAG, SnowflakeParserLANGUAGE, SnowflakeParserLARGE, SnowflakeParserLAST, SnowflakeParserLAST_NAME, SnowflakeParserLAST_QUERY_ID, SnowflakeParserLAST_VALUE, SnowflakeParserLEAD, SnowflakeParserLEN, SnowflakeParserLENGTH, SnowflakeParserLEVEL, SnowflakeParserLIMIT, SnowflakeParserLINENO, SnowflakeParserLIST, SnowflakeParserLISTENER_IP, SnowflakeParserLISTENER_PORT, SnowflakeParserLISTING, SnowflakeParserLOAD, SnowflakeParserLOCAL, SnowflakeParserLOCAL_SERVICE_NAME, SnowflakeParserLOCATION, SnowflakeParserLOCKS, SnowflakeParserLOCK_TIMEOUT, SnowflakeParserLOG, SnowflakeParserLOGIN, SnowflakeParserLOGIN_NAME, SnowflakeParserLOOKER, SnowflakeParserLOW, SnowflakeParserLOWER, SnowflakeParserLTRIM, SnowflakeParserLZO, SnowflakeParserMANAGE, SnowflakeParserMANAGED, SnowflakeParserMASK, SnowflakeParserMASKED, SnowflakeParserMASKING, SnowflakeParserMASTER, SnowflakeParserMASTER_KEY, SnowflakeParserMATCH, SnowflakeParserMATCHED, SnowflakeParserMATCHES, SnowflakeParserMATCH_BY_COLUMN_NAME, SnowflakeParserMATCH_RECOGNIZE, SnowflakeParserMATERIALIZED, SnowflakeParserMAX_BATCH_ROWS, SnowflakeParserMAX_CLUSTER_COUNT, SnowflakeParserMAX_CONCURRENCY_LEVEL, SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, SnowflakeParserMAX_SIZE, SnowflakeParserMEASURES, SnowflakeParserMEDIUM, SnowflakeParserMEMOIZABLE, SnowflakeParserMERGE, SnowflakeParserMIDDLE_NAME, SnowflakeParserMIN, SnowflakeParserMINS_TO_BYPASS_MFA, SnowflakeParserMINS_TO_UNLOCK, SnowflakeParserMINUS_, SnowflakeParserMINUTES, SnowflakeParserMIN_CLUSTER_COUNT, SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, SnowflakeParserMODE, SnowflakeParserMODIFIED_AFTER, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserMONITORS, SnowflakeParserMONTHLY, SnowflakeParserMOVE, SnowflakeParserMULTI_STATEMENT_COUNT, SnowflakeParserMULTI_USER, SnowflakeParserMUST_CHANGE, SnowflakeParserMUST_CHANGE_PASSWORD, SnowflakeParserNAME, SnowflakeParserNCHAR, SnowflakeParserNESTED_TRIGGERS, SnowflakeParserNETWORK, SnowflakeParserNETWORK_POLICY, SnowflakeParserNEVER, SnowflakeParserNEWID, SnowflakeParserNEWNAME, SnowflakeParserNEWSEQUENTIALID, SnowflakeParserNEW_ACCOUNT, SnowflakeParserNEW_BROKER, SnowflakeParserNEW_PASSWORD, SnowflakeParserNEXT, SnowflakeParserNEXTVAL, SnowflakeParserNO, SnowflakeParserNONE, SnowflakeParserNONE_Q, SnowflakeParserNORELY, SnowflakeParserNOTIFICATION, SnowflakeParserNOTIFICATIONS, SnowflakeParserNOTIFICATION_INTEGRATION, SnowflakeParserNOTIFICATION_PROVIDER, SnowflakeParserNOTIFY, SnowflakeParserNOTIFY_USERS, SnowflakeParserNOVALIDATE, SnowflakeParserNTILE, SnowflakeParserNULLIF, SnowflakeParserNULLS, SnowflakeParserNULL_, SnowflakeParserNULL_IF, SnowflakeParserNUMANODE, SnowflakeParserNUMBER, SnowflakeParserNUMERIC_ROUNDABORT, SnowflakeParserNVL, SnowflakeParserOAUTH, SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, SnowflakeParserOAUTH_CLIENT, SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, SnowflakeParserOAUTH_ENFORCE_PKCE, SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, SnowflakeParserOAUTH_REDIRECT_URI, SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, SnowflakeParserOAUTH_USE_SECONDARY_ROLES, SnowflakeParserOBJECT, SnowflakeParserOBJECT_Q, SnowflakeParserOBJECTS, SnowflakeParserOBJECT_TYPES, SnowflakeParserOFF, SnowflakeParserOFFSET, SnowflakeParserOFFSETS, SnowflakeParserOKTA, SnowflakeParserOKTA_PROVISIONER_Q, SnowflakeParserOKTA_Q, SnowflakeParserOLD, SnowflakeParserOLD_ACCOUNT, SnowflakeParserOLD_PASSWORD, SnowflakeParserOMIT, SnowflakeParserONE, SnowflakeParserONLINE, SnowflakeParserONLY, SnowflakeParserON_ERROR, SnowflakeParserON_FAILURE, SnowflakeParserOPEN, SnowflakeParserOPERATE, SnowflakeParserOPERATIONS, SnowflakeParserOPTIMIZATION, SnowflakeParserOPTION, SnowflakeParserORC, SnowflakeParserORC_Q, SnowflakeParserORGADMIN, SnowflakeParserOUTBOUND, SnowflakeParserOUTER, SnowflakeParserOVER, SnowflakeParserOVERRIDE, SnowflakeParserOVERWRITE, SnowflakeParserOWNER, SnowflakeParserOWNERSHIP, SnowflakeParserPAGE, SnowflakeParserPARALLEL, SnowflakeParserPARAMETERS, SnowflakeParserPARAM_NODE, SnowflakeParserPARQUET, SnowflakeParserPARQUET_Q, SnowflakeParserPARTIAL, SnowflakeParserPARTITION, SnowflakeParserPARTITIONS, SnowflakeParserPARTITION_TYPE, SnowflakeParserPASSWORD, SnowflakeParserPAST, SnowflakeParserPATH_, SnowflakeParserPATTERN, SnowflakeParserPER, SnowflakeParserPERCENT, SnowflakeParserPERCENTILE_CONT, SnowflakeParserPERCENTILE_DISC, SnowflakeParserPERCENT_RANK, SnowflakeParserPERIODIC_DATA_REKEYING, SnowflakeParserPERMISSION_SET, SnowflakeParserPERSISTED, SnowflakeParserPERSIST_SAMPLE_PERCENT, SnowflakeParserPING_FEDERATE, SnowflakeParserPIPE, SnowflakeParserPIPES, SnowflakeParserPIPE_EXECUTION_PAUSED, SnowflakeParserPIVOT, SnowflakeParserPLAN, SnowflakeParserPLATFORM, SnowflakeParserPOLICIES, SnowflakeParserPOLICY, SnowflakeParserPOOL, SnowflakeParserPORT, SnowflakeParserPRECEDING, SnowflakeParserPRECISION, SnowflakeParserPREDICATE, SnowflakeParserPREFIX, SnowflakeParserPRESERVE_SPACE, SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, SnowflakeParserPRIMARY, SnowflakeParserPRIMARY_ROLE, SnowflakeParserPRIOR, SnowflakeParserPRIORITY, SnowflakeParserPRIORITY_LEVEL, SnowflakeParserPRIVATE, SnowflakeParserPRIVATE_KEY, SnowflakeParserPRIVILEGES, SnowflakeParserPROC, SnowflakeParserPROCEDURE, SnowflakeParserPROCEDURES, SnowflakeParserPROCEDURE_NAME, SnowflakeParserPROCESS, SnowflakeParserPROFILE, SnowflakeParserPROPERTY, SnowflakeParserPROVIDER, SnowflakeParserPROVIDER_KEY_NAME, SnowflakeParserPUBLIC, SnowflakeParserPURGE, SnowflakeParserPUT, SnowflakeParserPYTHON, SnowflakeParserQUERIES, SnowflakeParserQUERY, SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, SnowflakeParserQUERY_TAG, SnowflakeParserQUEUE, SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, SnowflakeParserRANGE, SnowflakeParserRANK, SnowflakeParserRAW_DEFLATE, SnowflakeParserREAD, SnowflakeParserREADER, SnowflakeParserREADONLY, SnowflakeParserREADPAST, SnowflakeParserREADTEXT, SnowflakeParserREADWRITE, SnowflakeParserREAD_COMMITTED_SNAPSHOT, SnowflakeParserREAD_ONLY, SnowflakeParserREAD_ONLY_ROUTING_LIST, SnowflakeParserREAD_WRITE, SnowflakeParserREBUILD, SnowflakeParserRECEIVE, SnowflakeParserRECLUSTER, SnowflakeParserRECOMPILE, SnowflakeParserRECONFIGURE, SnowflakeParserRECORD_DELIMITER, SnowflakeParserRECOVERY, SnowflakeParserRECURSIVE, SnowflakeParserRECURSIVE_TRIGGERS, SnowflakeParserREFERENCES, SnowflakeParserREFERENCE_USAGE, SnowflakeParserREFRESH, SnowflakeParserREFRESH_ON_CREATE, SnowflakeParserREGION, SnowflakeParserREGIONS, SnowflakeParserREGION_GROUP, SnowflakeParserRELATIVE, SnowflakeParserRELY, SnowflakeParserREMOTE, SnowflakeParserREMOTE_PROC_TRANSACTIONS, SnowflakeParserREMOTE_SERVICE_NAME, SnowflakeParserREMOVE, SnowflakeParserRENAME, SnowflakeParserREPEATABLE, SnowflakeParserREPLACE, SnowflakeParserREPLACE_INVALID_CHARACTERS, SnowflakeParserREPLICA, SnowflakeParserREPLICATION, SnowflakeParserREPLICATION_SCHEDULE, SnowflakeParserREQUEST_TRANSLATOR, SnowflakeParserREQUIRED, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, SnowflakeParserRESET, SnowflakeParserRESOURCE, SnowflakeParserRESOURCES, SnowflakeParserRESOURCE_MONITOR, SnowflakeParserRESPONSE_TRANSLATOR, SnowflakeParserRESTART, SnowflakeParserRESTORE, SnowflakeParserRESTRICT, SnowflakeParserRESTRICTIONS, SnowflakeParserRESULT, SnowflakeParserRESUME, SnowflakeParserRETAINDAYS, SnowflakeParserRETURN, SnowflakeParserRETURNS, SnowflakeParserRETURN_ALL_ERRORS, SnowflakeParserRETURN_ERRORS, SnowflakeParserRETURN_FAILED_ONLY, SnowflakeParserRETURN_N_ROWS, SnowflakeParserRETURN_ROWS, SnowflakeParserREVERSE, SnowflakeParserREVERT, SnowflakeParserREWIND, SnowflakeParserROLE, SnowflakeParserROLES, SnowflakeParserROLLBACK, SnowflakeParserROLLUP, SnowflakeParserROOT, SnowflakeParserROWCOUNT, SnowflakeParserROWGUID, SnowflakeParserROWLOCK, SnowflakeParserROWS_PER_RESULTSET, SnowflakeParserROW_NUMBER, SnowflakeParserRSA_PUBLIC_KEY, SnowflakeParserRTRIM, SnowflakeParserRUN_AS_ROLE, SnowflakeParserSAFE, SnowflakeParserSAFETY, SnowflakeParserSAML_IDENTITY_PROVIDER, SnowflakeParserSAVE_OLD_URL, SnowflakeParserSCALING_POLICY, SnowflakeParserSCHEDULE, SnowflakeParserSCHEDULER, SnowflakeParserSCHEMA, SnowflakeParserSCHEMAS, SnowflakeParserSCHEME, SnowflakeParserSCIM, SnowflakeParserSCIM_CLIENT, SnowflakeParserSCRIPT, SnowflakeParserSEARCH, SnowflakeParserSECONDARY, SnowflakeParserSECONDARY_ONLY, SnowflakeParserSECONDARY_ROLE, SnowflakeParserSECONDS, SnowflakeParserSECRET, SnowflakeParserSECURE, SnowflakeParserSECURITY, SnowflakeParserSECURITYADMIN, SnowflakeParserSEED, SnowflakeParserSELF, SnowflakeParserSEQUENCE, SnowflakeParserSEQUENCES, SnowflakeParserSERVER, SnowflakeParserSERVICE, SnowflakeParserSESSION, SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, SnowflakeParserSESSION_POLICY, SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, SnowflakeParserSETS, SnowflakeParserSETUSER, SnowflakeParserSHARE, SnowflakeParserSHARED, SnowflakeParserSHARES, SnowflakeParserSHARE_RESTRICTIONS, SnowflakeParserSHOW, SnowflakeParserSHOWPLAN, SnowflakeParserSHOWPLAN_ALL, SnowflakeParserSHOWPLAN_TEXT, SnowflakeParserSHOWPLAN_XML, SnowflakeParserSHOW_INITIAL_ROWS, SnowflakeParserSIGNATURE, SnowflakeParserSIMPLE, SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, SnowflakeParserSINGLE_USER, SnowflakeParserSIZE, SnowflakeParserSIZE_LIMIT, SnowflakeParserSKIP_, SnowflakeParserSKIP_BLANK_LINES, SnowflakeParserSKIP_BYTE_ORDER_MARK, SnowflakeParserSKIP_FILE, SnowflakeParserSKIP_FILE_N, SnowflakeParserSKIP_HEADER, SnowflakeParserSMALL, SnowflakeParserSNAPPY, SnowflakeParserSNAPPY_COMPRESSION, SnowflakeParserSOUNDEX, SnowflakeParserSOURCE, SnowflakeParserSOURCE_COMPRESSION, SnowflakeParserSPACE_KEYWORD, SnowflakeParserSPARSE, SnowflakeParserSPECIFICATION, SnowflakeParserSPLIT, SnowflakeParserSPLIT_PART, SnowflakeParserSQL, SnowflakeParserSSO_LOGIN_PAGE, SnowflakeParserSTAGE, SnowflakeParserSTAGES, SnowflakeParserSTAGE_COPY_OPTIONS, SnowflakeParserSTAGE_FILE_FORMAT, SnowflakeParserSTANDARD, SnowflakeParserSTANDBY, SnowflakeParserSTARTED, SnowflakeParserSTARTS, SnowflakeParserSTART_DATE, SnowflakeParserSTART_TIMESTAMP, SnowflakeParserSTATE, SnowflakeParserSTATEMENT, SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, SnowflakeParserSTATIC, SnowflakeParserSTATISTICS, SnowflakeParserSTATS, SnowflakeParserSTATS_DATE, SnowflakeParserSTATS_STREAM, SnowflakeParserSTATUS, SnowflakeParserSTATUSONLY, SnowflakeParserSTDEV, SnowflakeParserSTDEVP, SnowflakeParserSTOP, SnowflakeParserSTOPLIST, SnowflakeParserSTOPPED, SnowflakeParserSTORAGE, SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, SnowflakeParserSTORAGE_AWS_OBJECT_ACL, SnowflakeParserSTORAGE_AWS_ROLE_ARN, SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, SnowflakeParserSTORAGE_INTEGRATION, SnowflakeParserSTORAGE_PROVIDER, SnowflakeParserSTR, SnowflakeParserSTREAM, SnowflakeParserSTREAMS, SnowflakeParserSTRICT, SnowflakeParserSTRICT_JSON_OUTPUT, SnowflakeParserSTRING_AGG, SnowflakeParserSTRING_ESCAPE, SnowflakeParserSTRIP_NULL_VALUES, SnowflakeParserSTRIP_OUTER_ARRAY, SnowflakeParserSTRIP_OUTER_ELEMENT, SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING, SnowflakeParserSUM, SnowflakeParserSUPPORTED, SnowflakeParserSUSPEND, SnowflakeParserSUSPENDED, SnowflakeParserSUSPEND_IMMEDIATE, SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, SnowflakeParserSWAP, SnowflakeParserSWITCH, SnowflakeParserSYNC_PASSWORD, SnowflakeParserSYSADMIN, SnowflakeParserSYSTEM, SnowflakeParserSYSTEM_USER, SnowflakeParserTABLEAU_DESKTOP, SnowflakeParserTABLEAU_SERVER, SnowflakeParserTABLES, SnowflakeParserTABLE_FORMAT, SnowflakeParserTABULAR, SnowflakeParserTAG, SnowflakeParserTAGS, SnowflakeParserTARGET, SnowflakeParserTARGET_LAG, SnowflakeParserTASK, SnowflakeParserTASKS, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserTERSE, SnowflakeParserTEXTSIZE, SnowflakeParserTIES, SnowflakeParserTIME, SnowflakeParserTIMEADD, SnowflakeParserTIMEDIFF, SnowflakeParserTIMEOUT, SnowflakeParserTIMER, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_FORMAT, SnowflakeParserTIMESTAMP_INPUT_FORMAT, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_TYPE_MAPPING, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMPADD, SnowflakeParserTIMESTAMPDIFF, SnowflakeParserTIMEZONE, SnowflakeParserTIME_FORMAT, SnowflakeParserTIME_INPUT_FORMAT, SnowflakeParserTIME_OUTPUT_FORMAT, SnowflakeParserTO_BOOLEAN, SnowflakeParserTO_DATE, SnowflakeParserTOP, SnowflakeParserTORN_PAGE_DETECTION, SnowflakeParserTRACKING, SnowflakeParserTRACK_CAUSALITY, SnowflakeParserTRAN, SnowflakeParserTRANSACTION, SnowflakeParserTRANSACTIONS, SnowflakeParserTRANSACTION_ABORT_ON_ERROR, SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, SnowflakeParserTRANSACTION_ID, SnowflakeParserTRANSFORM_NOISE_WORDS, SnowflakeParserTRANSIENT, SnowflakeParserTRANSLATE, SnowflakeParserTRIGGERS, SnowflakeParserTRIM, SnowflakeParserTRIM_SPACE, SnowflakeParserTRIPLE_DES, SnowflakeParserTRUNCATE, SnowflakeParserTRUNCATECOLUMNS, SnowflakeParserTRUSTWORTHY, SnowflakeParserTRY, SnowflakeParserTSEQUAL, SnowflakeParserTSQL, SnowflakeParserTWO_DIGIT_CENTURY_START, SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, SnowflakeParserTYPE, SnowflakeParserTYPEPROPERTY, SnowflakeParserTYPE_ID, SnowflakeParserTYPE_NAME, SnowflakeParserTYPE_WARNING, SnowflakeParserUN, SnowflakeParserUNBOUNDED, SnowflakeParserUNCHECKED, SnowflakeParserUNCOMMITTED, SnowflakeParserUNDROP, SnowflakeParserUNICODE, SnowflakeParserUNKNOWN, SnowflakeParserUNLIMITED, SnowflakeParserUNLOCK, SnowflakeParserUNMASK, SnowflakeParserUNMATCHED, SnowflakeParserUNPIVOT, SnowflakeParserUNSAFE, SnowflakeParserUNSET, SnowflakeParserUNSUPPORTED_DDL_ACTION, SnowflakeParserUOW, SnowflakeParserUPDLOCK, SnowflakeParserUPPER, SnowflakeParserURL, SnowflakeParserUSAGE, SnowflakeParserUSE, SnowflakeParserUSED, SnowflakeParserUSER, SnowflakeParserUSERADMIN, SnowflakeParserUSERS, SnowflakeParserUSER_SPECIFIED, SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, SnowflakeParserUSER_TASK_TIMEOUT_MS, SnowflakeParserUSE_ANY_ROLE, SnowflakeParserUSE_CACHED_RESULT, SnowflakeParserVALIDATE, SnowflakeParserVALIDATION, SnowflakeParserVALIDATION_MODE, SnowflakeParserVALID_XML, SnowflakeParserVALUE, SnowflakeParserVAR, SnowflakeParserVARIABLES, SnowflakeParserVARP, SnowflakeParserVARYING, SnowflakeParserVERSION, SnowflakeParserVIEWS, SnowflakeParserVIEW_METADATA, SnowflakeParserVISIBILITY, SnowflakeParserVOLATILE, SnowflakeParserWAIT, SnowflakeParserWAREHOUSE, SnowflakeParserWAREHOUSES, SnowflakeParserWAREHOUSE_SIZE, SnowflakeParserWEEKLY, SnowflakeParserWEEK_OF_YEAR_POLICY, SnowflakeParserWEEK_START, SnowflakeParserWELL_FORMED_XML, SnowflakeParserWITHIN, SnowflakeParserWITHOUT, SnowflakeParserWITHOUT_ARRAY_WRAPPER, SnowflakeParserWORK, SnowflakeParserWORKLOAD, SnowflakeParserWRITE, SnowflakeParserXLARGE, SnowflakeParserXLOCK, SnowflakeParserXML, SnowflakeParserXML_Q, SnowflakeParserXSMALL, SnowflakeParserXXLARGE, SnowflakeParserXXXLARGE, SnowflakeParserYEARLY, SnowflakeParserZSTD, SnowflakeParserARRAY, SnowflakeParserARRAY_Q, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserCHAR_VARYING, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNCHAR_VARYING, SnowflakeParserNUMERIC, SnowflakeParserNVARCHAR, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT, SnowflakeParserLISTAGG, SnowflakeParserDUMMY, SnowflakeParserDOUBLE_QUOTE_ID, SnowflakeParserDOUBLE_QUOTE_BLANK, SnowflakeParserID, SnowflakeParserID2, SnowflakeParserRR_BRACKET, SnowflakeParserSEMI: + p.SetState(10364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSCHEMA { + { + p.SetState(10363) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10367) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1326, p.GetParserRuleContext()) == 1 { + { + p.SetState(10366) + p.Schema_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(10374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTARTS { + { + p.SetState(10373) + p.Starts_with() + } + + } + p.SetState(10377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIMIT { + { + p.SetState(10376) + p.Limit_rows() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_transactionsContext is an interface to support dynamic dispatch. +type IShow_transactionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + TRANSACTIONS() antlr.TerminalNode + IN() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + + // IsShow_transactionsContext differentiates from other interfaces. + IsShow_transactionsContext() +} + +type Show_transactionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_transactionsContext() *Show_transactionsContext { + var p = new(Show_transactionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_transactions + return p +} + +func InitEmptyShow_transactionsContext(p *Show_transactionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_transactions +} + +func (*Show_transactionsContext) IsShow_transactionsContext() {} + +func NewShow_transactionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_transactionsContext { + var p = new(Show_transactionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_transactions + + return p +} + +func (s *Show_transactionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_transactionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_transactionsContext) TRANSACTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTIONS, 0) +} + +func (s *Show_transactionsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_transactionsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_transactionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_transactionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_transactionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_transactions(s) + } +} + +func (s *Show_transactionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_transactions(s) + } +} + +func (s *Show_transactionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_transactions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_transactions() (localctx IShow_transactionsContext) { + localctx = NewShow_transactionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 818, SnowflakeParserRULE_show_transactions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10379) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10380) + p.Match(SnowflakeParserTRANSACTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10381) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10382) + p.Match(SnowflakeParserACCOUNT) + 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 +} + +// IShow_user_functionsContext is an interface to support dynamic dispatch. +type IShow_user_functionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + USER() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + Like_pattern() ILike_patternContext + In_obj() IIn_objContext + + // IsShow_user_functionsContext differentiates from other interfaces. + IsShow_user_functionsContext() +} + +type Show_user_functionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_user_functionsContext() *Show_user_functionsContext { + var p = new(Show_user_functionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_user_functions + return p +} + +func InitEmptyShow_user_functionsContext(p *Show_user_functionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_user_functions +} + +func (*Show_user_functionsContext) IsShow_user_functionsContext() {} + +func NewShow_user_functionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_user_functionsContext { + var p = new(Show_user_functionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_user_functions + + return p +} + +func (s *Show_user_functionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_user_functionsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_user_functionsContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Show_user_functionsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTIONS, 0) +} + +func (s *Show_user_functionsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_user_functionsContext) In_obj() IIn_objContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_objContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_objContext) +} + +func (s *Show_user_functionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_user_functionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_user_functionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_user_functions(s) + } +} + +func (s *Show_user_functionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_user_functions(s) + } +} + +func (s *Show_user_functionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_user_functions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_user_functions() (localctx IShow_user_functionsContext) { + localctx = NewShow_user_functionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 820, SnowflakeParserRULE_show_user_functions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10385) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10386) + p.Match(SnowflakeParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10387) + p.Match(SnowflakeParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10388) + p.Like_pattern() + } + + } + p.SetState(10392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10391) + p.In_obj() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_usersContext is an interface to support dynamic dispatch. +type IShow_usersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + USERS() antlr.TerminalNode + TERSE() antlr.TerminalNode + Like_pattern() ILike_patternContext + STARTS() antlr.TerminalNode + WITH() antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + LIMIT() antlr.TerminalNode + Num() INumContext + FROM() antlr.TerminalNode + + // IsShow_usersContext differentiates from other interfaces. + IsShow_usersContext() +} + +type Show_usersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_usersContext() *Show_usersContext { + var p = new(Show_usersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_users + return p +} + +func InitEmptyShow_usersContext(p *Show_usersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_users +} + +func (*Show_usersContext) IsShow_usersContext() {} + +func NewShow_usersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_usersContext { + var p = new(Show_usersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_users + + return p +} + +func (s *Show_usersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_usersContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_usersContext) USERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSERS, 0) +} + +func (s *Show_usersContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Show_usersContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_usersContext) STARTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTARTS, 0) +} + +func (s *Show_usersContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Show_usersContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Show_usersContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Show_usersContext) LIMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIMIT, 0) +} + +func (s *Show_usersContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Show_usersContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *Show_usersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_usersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_usersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_users(s) + } +} + +func (s *Show_usersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_users(s) + } +} + +func (s *Show_usersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_users(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_users() (localctx IShow_usersContext) { + localctx = NewShow_usersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 822, SnowflakeParserRULE_show_users) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10394) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTERSE { + { + p.SetState(10395) + p.Match(SnowflakeParserTERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10398) + p.Match(SnowflakeParserUSERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10399) + p.Like_pattern() + } + + } + p.SetState(10405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTARTS { + { + p.SetState(10402) + p.Match(SnowflakeParserSTARTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10403) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10404) + p.String_() + } + + } + p.SetState(10409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIMIT { + { + p.SetState(10407) + p.Match(SnowflakeParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10408) + p.Num() + } + + } + p.SetState(10413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFROM { + { + p.SetState(10411) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10412) + p.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 +} + +// IShow_variablesContext is an interface to support dynamic dispatch. +type IShow_variablesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + VARIABLES() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_variablesContext differentiates from other interfaces. + IsShow_variablesContext() +} + +type Show_variablesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_variablesContext() *Show_variablesContext { + var p = new(Show_variablesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_variables + return p +} + +func InitEmptyShow_variablesContext(p *Show_variablesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_variables +} + +func (*Show_variablesContext) IsShow_variablesContext() {} + +func NewShow_variablesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_variablesContext { + var p = new(Show_variablesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_variables + + return p +} + +func (s *Show_variablesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_variablesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_variablesContext) VARIABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARIABLES, 0) +} + +func (s *Show_variablesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_variablesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_variablesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_variablesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_variables(s) + } +} + +func (s *Show_variablesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_variables(s) + } +} + +func (s *Show_variablesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_variables(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_variables() (localctx IShow_variablesContext) { + localctx = NewShow_variablesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 824, SnowflakeParserRULE_show_variables) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10415) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10416) + p.Match(SnowflakeParserVARIABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10417) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_viewsContext is an interface to support dynamic dispatch. +type IShow_viewsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + VIEWS() antlr.TerminalNode + TERSE() antlr.TerminalNode + Like_pattern() ILike_patternContext + IN() antlr.TerminalNode + Starts_with() IStarts_withContext + Limit_rows() ILimit_rowsContext + ACCOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_() IId_Context + SCHEMA() antlr.TerminalNode + Schema_name() ISchema_nameContext + + // IsShow_viewsContext differentiates from other interfaces. + IsShow_viewsContext() +} + +type Show_viewsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_viewsContext() *Show_viewsContext { + var p = new(Show_viewsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_views + return p +} + +func InitEmptyShow_viewsContext(p *Show_viewsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_views +} + +func (*Show_viewsContext) IsShow_viewsContext() {} + +func NewShow_viewsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_viewsContext { + var p = new(Show_viewsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_views + + return p +} + +func (s *Show_viewsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_viewsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_viewsContext) VIEWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEWS, 0) +} + +func (s *Show_viewsContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Show_viewsContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_viewsContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Show_viewsContext) Starts_with() IStarts_withContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStarts_withContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStarts_withContext) +} + +func (s *Show_viewsContext) Limit_rows() ILimit_rowsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILimit_rowsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILimit_rowsContext) +} + +func (s *Show_viewsContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Show_viewsContext) DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASE, 0) +} + +func (s *Show_viewsContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Show_viewsContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMA, 0) +} + +func (s *Show_viewsContext) Schema_name() ISchema_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_nameContext) +} + +func (s *Show_viewsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_viewsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_viewsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_views(s) + } +} + +func (s *Show_viewsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_views(s) + } +} + +func (s *Show_viewsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_views(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_views() (localctx IShow_viewsContext) { + localctx = NewShow_viewsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 826, SnowflakeParserRULE_show_views) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10420) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserTERSE { + { + p.SetState(10421) + p.Match(SnowflakeParserTERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10424) + p.Match(SnowflakeParserVIEWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10425) + p.Like_pattern() + } + + } + p.SetState(10442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserIN { + { + p.SetState(10428) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT: + { + p.SetState(10429) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASE: + { + p.SetState(10430) + p.Match(SnowflakeParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10432) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1342, p.GetParserRuleContext()) == 1 { + { + p.SetState(10431) + p.Id_() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserEOF, SnowflakeParserAAD_PROVISIONER_Q, SnowflakeParserABORT, SnowflakeParserABORT_AFTER_WAIT, SnowflakeParserABORT_DETACHED_QUERY, SnowflakeParserABORT_STATEMENT, SnowflakeParserABSENT, SnowflakeParserABSOLUTE, SnowflakeParserACCESS, SnowflakeParserACCOUNTADMIN, SnowflakeParserACCOUNTS, SnowflakeParserACTION, SnowflakeParserACTIVE, SnowflakeParserADD, SnowflakeParserADMINISTER, SnowflakeParserADMIN_NAME, SnowflakeParserADMIN_PASSWORD, SnowflakeParserAES, SnowflakeParserAFTER, SnowflakeParserAGGREGATE, SnowflakeParserALERT, SnowflakeParserALERTS, SnowflakeParserALLOWED, SnowflakeParserALLOWED_ACCOUNTS, SnowflakeParserALLOWED_DATABASES, SnowflakeParserALLOWED_INTEGRATION_TYPES, SnowflakeParserALLOWED_IP_LIST, SnowflakeParserALLOWED_SHARES, SnowflakeParserALLOWED_VALUES, SnowflakeParserALLOW_CLIENT_MFA_CACHING, SnowflakeParserALLOW_CONNECTIONS, SnowflakeParserALLOW_DUPLICATE, SnowflakeParserALLOW_ID_TOKEN, SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, SnowflakeParserALLOW_OVERLAPPING_EXECUTION, SnowflakeParserALLOW_SINGLE_EVENT_LOSS, SnowflakeParserALWAYS, SnowflakeParserANONYMOUS, SnowflakeParserANSI_DEFAULTS, SnowflakeParserAPI, SnowflakeParserAPI_ALLOWED_PREFIXES, SnowflakeParserAPI_AWS_ROLE_ARN, SnowflakeParserAPI_BLOCKED_PREFIXES, SnowflakeParserAPI_INTEGRATION, SnowflakeParserAPI_KEY, SnowflakeParserAPI_PROVIDER, SnowflakeParserAPPEND, SnowflakeParserAPPEND_ONLY, SnowflakeParserAPPLICATION, SnowflakeParserAPPLY, SnowflakeParserAPP_NAME, SnowflakeParserASC, SnowflakeParserATTACH, SnowflakeParserAT_KEYWORD, SnowflakeParserAUTHORIZATION, SnowflakeParserAUTHORIZATIONS, SnowflakeParserAUTO, SnowflakeParserAUTO_Q, SnowflakeParserAUTOCOMMIT, SnowflakeParserAUTOCOMMIT_API_SUPPORTED, SnowflakeParserAUTOINCREMENT, SnowflakeParserAUTO_COMPRESS, SnowflakeParserAUTO_DETECT, SnowflakeParserAUTO_INGEST, SnowflakeParserAUTO_REFRESH, SnowflakeParserAUTO_RESUME, SnowflakeParserAUTO_SUSPEND, SnowflakeParserAVG, SnowflakeParserAVRO, SnowflakeParserAVRO_Q, SnowflakeParserAWS_KEY_ID, SnowflakeParserAWS_ROLE, SnowflakeParserAWS_SECRET_KEY, SnowflakeParserAWS_SNS, SnowflakeParserAWS_SNS_ROLE_ARN, SnowflakeParserAWS_SNS_TOPIC, SnowflakeParserAWS_SNS_TOPIC_ARN, SnowflakeParserAWS_TOKEN, SnowflakeParserAZURE, SnowflakeParserAZURE_AD_APPLICATION_ID, SnowflakeParserAZURE_EVENT_GRID, SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, SnowflakeParserAZURE_Q, SnowflakeParserAZURE_SAS_TOKEN, SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, SnowflakeParserAZURE_TENANT_ID, SnowflakeParserBEFORE, SnowflakeParserBEGIN, SnowflakeParserBERNOULLI, SnowflakeParserBINARY_AS_TEXT, SnowflakeParserBINARY_CHECKSUM, SnowflakeParserBINARY_FORMAT, SnowflakeParserBINARY_INPUT_FORMAT, SnowflakeParserBINARY_OUTPUT_FORMAT, SnowflakeParserBINDING, SnowflakeParserBLOCK, SnowflakeParserBLOCKED_IP_LIST, SnowflakeParserBLOCKED_ROLES_LIST, SnowflakeParserBODY, SnowflakeParserBOTH_Q, SnowflakeParserBROTLI, SnowflakeParserBUSINESS_CRITICAL, SnowflakeParserCACHE, SnowflakeParserCALL, SnowflakeParserCALLED, SnowflakeParserCALLER, SnowflakeParserCASCADE, SnowflakeParserCASE_INSENSITIVE, SnowflakeParserCASE_SENSITIVE, SnowflakeParserCATCH, SnowflakeParserCERTIFICATE, SnowflakeParserCHANGE, SnowflakeParserCHANGES, SnowflakeParserCHANGETABLE, SnowflakeParserCHANGE_RETENTION, SnowflakeParserCHANGE_TRACKING, SnowflakeParserCHAR, SnowflakeParserCHARACTER, SnowflakeParserCHARINDEX, SnowflakeParserCHECKSUM, SnowflakeParserCHECKSUM_AGG, SnowflakeParserCHECK_EXPIRATION, SnowflakeParserCHECK_POLICY, SnowflakeParserCLASSIFIER_FUNCTION, SnowflakeParserCLEANUP, SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, SnowflakeParserCLIENT_MEMORY_LIMIT, SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, SnowflakeParserCLIENT_PREFETCH_THREADS, SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, SnowflakeParserCLONE, SnowflakeParserCLOSE, SnowflakeParserCLUSTER, SnowflakeParserCLUSTERED, SnowflakeParserCLUSTERING, SnowflakeParserCOALESCE, SnowflakeParserCOLLATE, SnowflakeParserCOLLECTION, SnowflakeParserCOLUMNS, SnowflakeParserCOL_LENGTH, SnowflakeParserCOL_NAME, SnowflakeParserCOMMENT, SnowflakeParserCOMMIT, SnowflakeParserCOMMITTED, SnowflakeParserCOMPRESS, SnowflakeParserCOMPRESSION, SnowflakeParserCONCAT, SnowflakeParserCONCAT_NULL_YIELDS_NULL, SnowflakeParserCONCAT_WS, SnowflakeParserCONDITION, SnowflakeParserCONFIGURATION, SnowflakeParserCONNECTIONS, SnowflakeParserCONTAINMENT, SnowflakeParserCONTAINS, SnowflakeParserCONTENT, SnowflakeParserCONTEXT, SnowflakeParserCONTEXT_HEADERS, SnowflakeParserCONTEXT_INFO, SnowflakeParserCONTINUE, SnowflakeParserCONTROL, SnowflakeParserCONVERSATION, SnowflakeParserCOOKIE, SnowflakeParserCOPY, SnowflakeParserCOPY_ONLY, SnowflakeParserCOPY_OPTIONS_, SnowflakeParserCOUNT, SnowflakeParserCOUNT_BIG, SnowflakeParserCREDENTIALS, SnowflakeParserCREDIT_QUOTA, SnowflakeParserCSV, SnowflakeParserCSV_Q, SnowflakeParserCUBE, SnowflakeParserCUME_DIST, SnowflakeParserCURRENT_DATE, SnowflakeParserCURRENT_TIMESTAMP, SnowflakeParserCURSOR, SnowflakeParserCUSTOM, SnowflakeParserDAILY, SnowflakeParserDATA, SnowflakeParserDATABASES, SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, SnowflakeParserDATEADD, SnowflakeParserDATEDIFF, SnowflakeParserDATENAME, SnowflakeParserDATEPART, SnowflakeParserDATE_FORMAT, SnowflakeParserDATE_INPUT_FORMAT, SnowflakeParserDATE_OUTPUT_FORMAT, SnowflakeParserDATE_PART, SnowflakeParserDAYS, SnowflakeParserDAYS_TO_EXPIRY, SnowflakeParserDECLARE, SnowflakeParserDEFAULT, SnowflakeParserDEFAULT_DDL_COLLATION_, SnowflakeParserDEFAULT_NAMESPACE, SnowflakeParserDEFAULT_ROLE, SnowflakeParserDEFAULT_WAREHOUSE, SnowflakeParserDEFERRABLE, SnowflakeParserDEFERRED, SnowflakeParserDEFINE, SnowflakeParserDEFINITION, SnowflakeParserDEFLATE, SnowflakeParserDELEGATED, SnowflakeParserDELTA, SnowflakeParserDENSE_RANK, SnowflakeParserDESC, SnowflakeParserDESCRIBE, SnowflakeParserDIRECTION, SnowflakeParserDIRECTORY, SnowflakeParserDISABLE, SnowflakeParserDISABLED, SnowflakeParserDISABLE_AUTO_CONVERT, SnowflakeParserDISABLE_SNOWFLAKE_DATA, SnowflakeParserDISK, SnowflakeParserDISPLAY_NAME, SnowflakeParserDO, SnowflakeParserDOWNSTREAM, SnowflakeParserDOUBLE, SnowflakeParserDYNAMIC, SnowflakeParserECONOMY, SnowflakeParserEDITION, SnowflakeParserEMAIL, SnowflakeParserEMPTY_, SnowflakeParserEMPTY_FIELD_AS_NULL, SnowflakeParserENABLE, SnowflakeParserENABLED, SnowflakeParserENABLE_FOR_PRIVILEGE, SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, SnowflakeParserENABLE_OCTAL, SnowflakeParserENABLE_QUERY_ACCELERATION, SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, SnowflakeParserENCODING, SnowflakeParserENCRYPTION, SnowflakeParserEND, SnowflakeParserENDPOINT, SnowflakeParserEND_TIMESTAMP, SnowflakeParserENFORCED, SnowflakeParserENFORCE_LENGTH, SnowflakeParserENFORCE_SESSION_POLICY, SnowflakeParserENTERPRISE, SnowflakeParserEQUALITY, SnowflakeParserERROR_INTEGRATION, SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, SnowflakeParserESCAPE, SnowflakeParserESCAPE_UNENCLOSED_FIELD, SnowflakeParserEXCEPT, SnowflakeParserEXCHANGE, SnowflakeParserEXECUTE, SnowflakeParserEXECUTION, SnowflakeParserEXIST, SnowflakeParserEXIT, SnowflakeParserEXPAND, SnowflakeParserEXPIRY_DATE, SnowflakeParserEXPLAIN, SnowflakeParserEXPLICIT, SnowflakeParserEXTERNAL, SnowflakeParserEXTERNAL_OAUTH, SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, SnowflakeParserEXTERNAL_OAUTH_ISSUER, SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, SnowflakeParserEXTERNAL_OAUTH_TYPE, SnowflakeParserEXTERNAL_STAGE, SnowflakeParserFAILOVER, SnowflakeParserFAILOVER_MODE, SnowflakeParserFAIL_OPERATION, SnowflakeParserFETCH, SnowflakeParserFIELD_DELIMITER, SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, SnowflakeParserFILE, SnowflakeParserFILES, SnowflakeParserFILE_EXTENSION, SnowflakeParserFILE_FORMAT, SnowflakeParserFILTER, SnowflakeParserFIRST, SnowflakeParserFIRST_NAME, SnowflakeParserFLATTEN, SnowflakeParserFORCE, SnowflakeParserFOREIGN, SnowflakeParserFORMAT, SnowflakeParserFORMATS, SnowflakeParserFORMAT_NAME, SnowflakeParserFREQUENCY, SnowflakeParserFUNCTION, SnowflakeParserFUNCTIONS, SnowflakeParserFUTURE, SnowflakeParserGCP_PUBSUB, SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, SnowflakeParserGCP_PUBSUB_TOPIC_NAME, SnowflakeParserGCS, SnowflakeParserGENERIC_Q, SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, SnowflakeParserGEO, SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, SnowflakeParserGEOMETRY_OUTPUT_FORMAT, SnowflakeParserGET, SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, SnowflakeParserGLOBAL, SnowflakeParserGOOGLE_AUDIENCE, SnowflakeParserGOTO, SnowflakeParserGRANTS, SnowflakeParserGROUPING, SnowflakeParserGROUPING_ID, SnowflakeParserGROUPS, SnowflakeParserGZIP, SnowflakeParserHEADER, SnowflakeParserHEADERS, SnowflakeParserHEX, SnowflakeParserHIERARCHYID, SnowflakeParserHIGH, SnowflakeParserHISTORY, SnowflakeParserHOURS, SnowflakeParserIDENTITY, SnowflakeParserIF, SnowflakeParserIFF, SnowflakeParserIFNULL, SnowflakeParserIGNORE, SnowflakeParserIGNORE_CONSTRAINTS, SnowflakeParserIGNORE_DUP_KEY, SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, SnowflakeParserIGNORE_TRIGGERS, SnowflakeParserIMMEDIATE, SnowflakeParserIMMEDIATELY, SnowflakeParserIMMUTABLE, SnowflakeParserIMPLICIT, SnowflakeParserIMPORT, SnowflakeParserIMPORTED, SnowflakeParserINDEX, SnowflakeParserINFORMATION, SnowflakeParserINIT, SnowflakeParserINITIALLY, SnowflakeParserINITIALLY_SUSPENDED, SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, SnowflakeParserINPUT, SnowflakeParserINSERT_ONLY, SnowflakeParserINSTEAD, SnowflakeParserINT, SnowflakeParserINTEGRATION, SnowflakeParserINTEGRATIONS, SnowflakeParserISNULL, SnowflakeParserISNUMERIC, SnowflakeParserISOLATION, SnowflakeParserJAVASCRIPT, SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, SnowflakeParserJDBC_USE_SESSION_TIMEZONE, SnowflakeParserJSON, SnowflakeParserJSON_Q, SnowflakeParserJSON_INDENT, SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, SnowflakeParserKB, SnowflakeParserKEEP, SnowflakeParserKEY, SnowflakeParserKEYS, SnowflakeParserKEYSET, SnowflakeParserKMS_KEY_ID, SnowflakeParserLAG, SnowflakeParserLANGUAGE, SnowflakeParserLARGE, SnowflakeParserLAST, SnowflakeParserLAST_NAME, SnowflakeParserLAST_QUERY_ID, SnowflakeParserLAST_VALUE, SnowflakeParserLEAD, SnowflakeParserLEN, SnowflakeParserLENGTH, SnowflakeParserLEVEL, SnowflakeParserLIMIT, SnowflakeParserLINENO, SnowflakeParserLIST, SnowflakeParserLISTENER_IP, SnowflakeParserLISTENER_PORT, SnowflakeParserLISTING, SnowflakeParserLOAD, SnowflakeParserLOCAL, SnowflakeParserLOCAL_SERVICE_NAME, SnowflakeParserLOCATION, SnowflakeParserLOCKS, SnowflakeParserLOCK_TIMEOUT, SnowflakeParserLOG, SnowflakeParserLOGIN, SnowflakeParserLOGIN_NAME, SnowflakeParserLOOKER, SnowflakeParserLOW, SnowflakeParserLOWER, SnowflakeParserLTRIM, SnowflakeParserLZO, SnowflakeParserMANAGE, SnowflakeParserMANAGED, SnowflakeParserMASK, SnowflakeParserMASKED, SnowflakeParserMASKING, SnowflakeParserMASTER, SnowflakeParserMASTER_KEY, SnowflakeParserMATCH, SnowflakeParserMATCHED, SnowflakeParserMATCHES, SnowflakeParserMATCH_BY_COLUMN_NAME, SnowflakeParserMATCH_RECOGNIZE, SnowflakeParserMATERIALIZED, SnowflakeParserMAX_BATCH_ROWS, SnowflakeParserMAX_CLUSTER_COUNT, SnowflakeParserMAX_CONCURRENCY_LEVEL, SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, SnowflakeParserMAX_SIZE, SnowflakeParserMEASURES, SnowflakeParserMEDIUM, SnowflakeParserMEMOIZABLE, SnowflakeParserMERGE, SnowflakeParserMIDDLE_NAME, SnowflakeParserMIN, SnowflakeParserMINS_TO_BYPASS_MFA, SnowflakeParserMINS_TO_UNLOCK, SnowflakeParserMINUS_, SnowflakeParserMINUTES, SnowflakeParserMIN_CLUSTER_COUNT, SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, SnowflakeParserMODE, SnowflakeParserMODIFIED_AFTER, SnowflakeParserMODIFY, SnowflakeParserMONITOR, SnowflakeParserMONITORS, SnowflakeParserMONTHLY, SnowflakeParserMOVE, SnowflakeParserMULTI_STATEMENT_COUNT, SnowflakeParserMULTI_USER, SnowflakeParserMUST_CHANGE, SnowflakeParserMUST_CHANGE_PASSWORD, SnowflakeParserNAME, SnowflakeParserNCHAR, SnowflakeParserNESTED_TRIGGERS, SnowflakeParserNETWORK, SnowflakeParserNETWORK_POLICY, SnowflakeParserNEVER, SnowflakeParserNEWID, SnowflakeParserNEWNAME, SnowflakeParserNEWSEQUENTIALID, SnowflakeParserNEW_ACCOUNT, SnowflakeParserNEW_BROKER, SnowflakeParserNEW_PASSWORD, SnowflakeParserNEXT, SnowflakeParserNEXTVAL, SnowflakeParserNO, SnowflakeParserNONE, SnowflakeParserNONE_Q, SnowflakeParserNORELY, SnowflakeParserNOTIFICATION, SnowflakeParserNOTIFICATIONS, SnowflakeParserNOTIFICATION_INTEGRATION, SnowflakeParserNOTIFICATION_PROVIDER, SnowflakeParserNOTIFY, SnowflakeParserNOTIFY_USERS, SnowflakeParserNOVALIDATE, SnowflakeParserNTILE, SnowflakeParserNULLIF, SnowflakeParserNULLS, SnowflakeParserNULL_, SnowflakeParserNULL_IF, SnowflakeParserNUMANODE, SnowflakeParserNUMBER, SnowflakeParserNUMERIC_ROUNDABORT, SnowflakeParserNVL, SnowflakeParserOAUTH, SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, SnowflakeParserOAUTH_CLIENT, SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, SnowflakeParserOAUTH_ENFORCE_PKCE, SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, SnowflakeParserOAUTH_REDIRECT_URI, SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, SnowflakeParserOAUTH_USE_SECONDARY_ROLES, SnowflakeParserOBJECT, SnowflakeParserOBJECT_Q, SnowflakeParserOBJECTS, SnowflakeParserOBJECT_TYPES, SnowflakeParserOFF, SnowflakeParserOFFSET, SnowflakeParserOFFSETS, SnowflakeParserOKTA, SnowflakeParserOKTA_PROVISIONER_Q, SnowflakeParserOKTA_Q, SnowflakeParserOLD, SnowflakeParserOLD_ACCOUNT, SnowflakeParserOLD_PASSWORD, SnowflakeParserOMIT, SnowflakeParserONE, SnowflakeParserONLINE, SnowflakeParserONLY, SnowflakeParserON_ERROR, SnowflakeParserON_FAILURE, SnowflakeParserOPEN, SnowflakeParserOPERATE, SnowflakeParserOPERATIONS, SnowflakeParserOPTIMIZATION, SnowflakeParserOPTION, SnowflakeParserORC, SnowflakeParserORC_Q, SnowflakeParserORGADMIN, SnowflakeParserOUTBOUND, SnowflakeParserOUTER, SnowflakeParserOVER, SnowflakeParserOVERRIDE, SnowflakeParserOVERWRITE, SnowflakeParserOWNER, SnowflakeParserOWNERSHIP, SnowflakeParserPAGE, SnowflakeParserPARALLEL, SnowflakeParserPARAMETERS, SnowflakeParserPARAM_NODE, SnowflakeParserPARQUET, SnowflakeParserPARQUET_Q, SnowflakeParserPARTIAL, SnowflakeParserPARTITION, SnowflakeParserPARTITIONS, SnowflakeParserPARTITION_TYPE, SnowflakeParserPASSWORD, SnowflakeParserPAST, SnowflakeParserPATH_, SnowflakeParserPATTERN, SnowflakeParserPER, SnowflakeParserPERCENT, SnowflakeParserPERCENTILE_CONT, SnowflakeParserPERCENTILE_DISC, SnowflakeParserPERCENT_RANK, SnowflakeParserPERIODIC_DATA_REKEYING, SnowflakeParserPERMISSION_SET, SnowflakeParserPERSISTED, SnowflakeParserPERSIST_SAMPLE_PERCENT, SnowflakeParserPING_FEDERATE, SnowflakeParserPIPE, SnowflakeParserPIPES, SnowflakeParserPIPE_EXECUTION_PAUSED, SnowflakeParserPIVOT, SnowflakeParserPLAN, SnowflakeParserPLATFORM, SnowflakeParserPOLICIES, SnowflakeParserPOLICY, SnowflakeParserPOOL, SnowflakeParserPORT, SnowflakeParserPRECEDING, SnowflakeParserPRECISION, SnowflakeParserPREDICATE, SnowflakeParserPREFIX, SnowflakeParserPRESERVE_SPACE, SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, SnowflakeParserPRIMARY, SnowflakeParserPRIMARY_ROLE, SnowflakeParserPRIOR, SnowflakeParserPRIORITY, SnowflakeParserPRIORITY_LEVEL, SnowflakeParserPRIVATE, SnowflakeParserPRIVATE_KEY, SnowflakeParserPRIVILEGES, SnowflakeParserPROC, SnowflakeParserPROCEDURE, SnowflakeParserPROCEDURES, SnowflakeParserPROCEDURE_NAME, SnowflakeParserPROCESS, SnowflakeParserPROFILE, SnowflakeParserPROPERTY, SnowflakeParserPROVIDER, SnowflakeParserPROVIDER_KEY_NAME, SnowflakeParserPUBLIC, SnowflakeParserPURGE, SnowflakeParserPUT, SnowflakeParserPYTHON, SnowflakeParserQUERIES, SnowflakeParserQUERY, SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, SnowflakeParserQUERY_TAG, SnowflakeParserQUEUE, SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, SnowflakeParserRANGE, SnowflakeParserRANK, SnowflakeParserRAW_DEFLATE, SnowflakeParserREAD, SnowflakeParserREADER, SnowflakeParserREADONLY, SnowflakeParserREADPAST, SnowflakeParserREADTEXT, SnowflakeParserREADWRITE, SnowflakeParserREAD_COMMITTED_SNAPSHOT, SnowflakeParserREAD_ONLY, SnowflakeParserREAD_ONLY_ROUTING_LIST, SnowflakeParserREAD_WRITE, SnowflakeParserREBUILD, SnowflakeParserRECEIVE, SnowflakeParserRECLUSTER, SnowflakeParserRECOMPILE, SnowflakeParserRECONFIGURE, SnowflakeParserRECORD_DELIMITER, SnowflakeParserRECOVERY, SnowflakeParserRECURSIVE, SnowflakeParserRECURSIVE_TRIGGERS, SnowflakeParserREFERENCES, SnowflakeParserREFERENCE_USAGE, SnowflakeParserREFRESH, SnowflakeParserREFRESH_ON_CREATE, SnowflakeParserREGION, SnowflakeParserREGIONS, SnowflakeParserREGION_GROUP, SnowflakeParserRELATIVE, SnowflakeParserRELY, SnowflakeParserREMOTE, SnowflakeParserREMOTE_PROC_TRANSACTIONS, SnowflakeParserREMOTE_SERVICE_NAME, SnowflakeParserREMOVE, SnowflakeParserRENAME, SnowflakeParserREPEATABLE, SnowflakeParserREPLACE, SnowflakeParserREPLACE_INVALID_CHARACTERS, SnowflakeParserREPLICA, SnowflakeParserREPLICATION, SnowflakeParserREPLICATION_SCHEDULE, SnowflakeParserREQUEST_TRANSLATOR, SnowflakeParserREQUIRED, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, SnowflakeParserRESET, SnowflakeParserRESOURCE, SnowflakeParserRESOURCES, SnowflakeParserRESOURCE_MONITOR, SnowflakeParserRESPONSE_TRANSLATOR, SnowflakeParserRESTART, SnowflakeParserRESTORE, SnowflakeParserRESTRICT, SnowflakeParserRESTRICTIONS, SnowflakeParserRESULT, SnowflakeParserRESUME, SnowflakeParserRETAINDAYS, SnowflakeParserRETURN, SnowflakeParserRETURNS, SnowflakeParserRETURN_ALL_ERRORS, SnowflakeParserRETURN_ERRORS, SnowflakeParserRETURN_FAILED_ONLY, SnowflakeParserRETURN_N_ROWS, SnowflakeParserRETURN_ROWS, SnowflakeParserREVERSE, SnowflakeParserREVERT, SnowflakeParserREWIND, SnowflakeParserROLE, SnowflakeParserROLES, SnowflakeParserROLLBACK, SnowflakeParserROLLUP, SnowflakeParserROOT, SnowflakeParserROWCOUNT, SnowflakeParserROWGUID, SnowflakeParserROWLOCK, SnowflakeParserROWS_PER_RESULTSET, SnowflakeParserROW_NUMBER, SnowflakeParserRSA_PUBLIC_KEY, SnowflakeParserRTRIM, SnowflakeParserRUN_AS_ROLE, SnowflakeParserSAFE, SnowflakeParserSAFETY, SnowflakeParserSAML_IDENTITY_PROVIDER, SnowflakeParserSAVE_OLD_URL, SnowflakeParserSCALING_POLICY, SnowflakeParserSCHEDULE, SnowflakeParserSCHEDULER, SnowflakeParserSCHEMA, SnowflakeParserSCHEMAS, SnowflakeParserSCHEME, SnowflakeParserSCIM, SnowflakeParserSCIM_CLIENT, SnowflakeParserSCRIPT, SnowflakeParserSEARCH, SnowflakeParserSECONDARY, SnowflakeParserSECONDARY_ONLY, SnowflakeParserSECONDARY_ROLE, SnowflakeParserSECONDS, SnowflakeParserSECRET, SnowflakeParserSECURE, SnowflakeParserSECURITY, SnowflakeParserSECURITYADMIN, SnowflakeParserSEED, SnowflakeParserSELF, SnowflakeParserSEQUENCE, SnowflakeParserSEQUENCES, SnowflakeParserSERVER, SnowflakeParserSERVICE, SnowflakeParserSESSION, SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, SnowflakeParserSESSION_POLICY, SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, SnowflakeParserSETS, SnowflakeParserSETUSER, SnowflakeParserSHARE, SnowflakeParserSHARED, SnowflakeParserSHARES, SnowflakeParserSHARE_RESTRICTIONS, SnowflakeParserSHOW, SnowflakeParserSHOWPLAN, SnowflakeParserSHOWPLAN_ALL, SnowflakeParserSHOWPLAN_TEXT, SnowflakeParserSHOWPLAN_XML, SnowflakeParserSHOW_INITIAL_ROWS, SnowflakeParserSIGNATURE, SnowflakeParserSIMPLE, SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, SnowflakeParserSINGLE_USER, SnowflakeParserSIZE, SnowflakeParserSIZE_LIMIT, SnowflakeParserSKIP_, SnowflakeParserSKIP_BLANK_LINES, SnowflakeParserSKIP_BYTE_ORDER_MARK, SnowflakeParserSKIP_FILE, SnowflakeParserSKIP_FILE_N, SnowflakeParserSKIP_HEADER, SnowflakeParserSMALL, SnowflakeParserSNAPPY, SnowflakeParserSNAPPY_COMPRESSION, SnowflakeParserSOUNDEX, SnowflakeParserSOURCE, SnowflakeParserSOURCE_COMPRESSION, SnowflakeParserSPACE_KEYWORD, SnowflakeParserSPARSE, SnowflakeParserSPECIFICATION, SnowflakeParserSPLIT, SnowflakeParserSPLIT_PART, SnowflakeParserSQL, SnowflakeParserSSO_LOGIN_PAGE, SnowflakeParserSTAGE, SnowflakeParserSTAGES, SnowflakeParserSTAGE_COPY_OPTIONS, SnowflakeParserSTAGE_FILE_FORMAT, SnowflakeParserSTANDARD, SnowflakeParserSTANDBY, SnowflakeParserSTARTED, SnowflakeParserSTARTS, SnowflakeParserSTART_DATE, SnowflakeParserSTART_TIMESTAMP, SnowflakeParserSTATE, SnowflakeParserSTATEMENT, SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, SnowflakeParserSTATIC, SnowflakeParserSTATISTICS, SnowflakeParserSTATS, SnowflakeParserSTATS_DATE, SnowflakeParserSTATS_STREAM, SnowflakeParserSTATUS, SnowflakeParserSTATUSONLY, SnowflakeParserSTDEV, SnowflakeParserSTDEVP, SnowflakeParserSTOP, SnowflakeParserSTOPLIST, SnowflakeParserSTOPPED, SnowflakeParserSTORAGE, SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, SnowflakeParserSTORAGE_AWS_OBJECT_ACL, SnowflakeParserSTORAGE_AWS_ROLE_ARN, SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, SnowflakeParserSTORAGE_INTEGRATION, SnowflakeParserSTORAGE_PROVIDER, SnowflakeParserSTR, SnowflakeParserSTREAM, SnowflakeParserSTREAMS, SnowflakeParserSTRICT, SnowflakeParserSTRICT_JSON_OUTPUT, SnowflakeParserSTRING_AGG, SnowflakeParserSTRING_ESCAPE, SnowflakeParserSTRIP_NULL_VALUES, SnowflakeParserSTRIP_OUTER_ARRAY, SnowflakeParserSTRIP_OUTER_ELEMENT, SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING, SnowflakeParserSUM, SnowflakeParserSUPPORTED, SnowflakeParserSUSPEND, SnowflakeParserSUSPENDED, SnowflakeParserSUSPEND_IMMEDIATE, SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, SnowflakeParserSWAP, SnowflakeParserSWITCH, SnowflakeParserSYNC_PASSWORD, SnowflakeParserSYSADMIN, SnowflakeParserSYSTEM, SnowflakeParserSYSTEM_USER, SnowflakeParserTABLEAU_DESKTOP, SnowflakeParserTABLEAU_SERVER, SnowflakeParserTABLES, SnowflakeParserTABLE_FORMAT, SnowflakeParserTABULAR, SnowflakeParserTAG, SnowflakeParserTAGS, SnowflakeParserTARGET, SnowflakeParserTARGET_LAG, SnowflakeParserTASK, SnowflakeParserTASKS, SnowflakeParserTEMP, SnowflakeParserTEMPORARY, SnowflakeParserTERSE, SnowflakeParserTEXTSIZE, SnowflakeParserTIES, SnowflakeParserTIME, SnowflakeParserTIMEADD, SnowflakeParserTIMEDIFF, SnowflakeParserTIMEOUT, SnowflakeParserTIMER, SnowflakeParserTIMESTAMP, SnowflakeParserTIMESTAMP_FORMAT, SnowflakeParserTIMESTAMP_INPUT_FORMAT, SnowflakeParserTIMESTAMP_LTZ, SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_NTZ, SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, SnowflakeParserTIMESTAMP_TYPE_MAPPING, SnowflakeParserTIMESTAMP_TZ, SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, SnowflakeParserTIMESTAMPADD, SnowflakeParserTIMESTAMPDIFF, SnowflakeParserTIMEZONE, SnowflakeParserTIME_FORMAT, SnowflakeParserTIME_INPUT_FORMAT, SnowflakeParserTIME_OUTPUT_FORMAT, SnowflakeParserTO_BOOLEAN, SnowflakeParserTO_DATE, SnowflakeParserTOP, SnowflakeParserTORN_PAGE_DETECTION, SnowflakeParserTRACKING, SnowflakeParserTRACK_CAUSALITY, SnowflakeParserTRAN, SnowflakeParserTRANSACTION, SnowflakeParserTRANSACTIONS, SnowflakeParserTRANSACTION_ABORT_ON_ERROR, SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, SnowflakeParserTRANSACTION_ID, SnowflakeParserTRANSFORM_NOISE_WORDS, SnowflakeParserTRANSIENT, SnowflakeParserTRANSLATE, SnowflakeParserTRIGGERS, SnowflakeParserTRIM, SnowflakeParserTRIM_SPACE, SnowflakeParserTRIPLE_DES, SnowflakeParserTRUNCATE, SnowflakeParserTRUNCATECOLUMNS, SnowflakeParserTRUSTWORTHY, SnowflakeParserTRY, SnowflakeParserTSEQUAL, SnowflakeParserTSQL, SnowflakeParserTWO_DIGIT_CENTURY_START, SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, SnowflakeParserTYPE, SnowflakeParserTYPEPROPERTY, SnowflakeParserTYPE_ID, SnowflakeParserTYPE_NAME, SnowflakeParserTYPE_WARNING, SnowflakeParserUN, SnowflakeParserUNBOUNDED, SnowflakeParserUNCHECKED, SnowflakeParserUNCOMMITTED, SnowflakeParserUNDROP, SnowflakeParserUNICODE, SnowflakeParserUNKNOWN, SnowflakeParserUNLIMITED, SnowflakeParserUNLOCK, SnowflakeParserUNMASK, SnowflakeParserUNMATCHED, SnowflakeParserUNPIVOT, SnowflakeParserUNSAFE, SnowflakeParserUNSET, SnowflakeParserUNSUPPORTED_DDL_ACTION, SnowflakeParserUOW, SnowflakeParserUPDLOCK, SnowflakeParserUPPER, SnowflakeParserURL, SnowflakeParserUSAGE, SnowflakeParserUSE, SnowflakeParserUSED, SnowflakeParserUSER, SnowflakeParserUSERADMIN, SnowflakeParserUSERS, SnowflakeParserUSER_SPECIFIED, SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, SnowflakeParserUSER_TASK_TIMEOUT_MS, SnowflakeParserUSE_ANY_ROLE, SnowflakeParserUSE_CACHED_RESULT, SnowflakeParserVALIDATE, SnowflakeParserVALIDATION, SnowflakeParserVALIDATION_MODE, SnowflakeParserVALID_XML, SnowflakeParserVALUE, SnowflakeParserVAR, SnowflakeParserVARIABLES, SnowflakeParserVARP, SnowflakeParserVARYING, SnowflakeParserVERSION, SnowflakeParserVIEWS, SnowflakeParserVIEW_METADATA, SnowflakeParserVISIBILITY, SnowflakeParserVOLATILE, SnowflakeParserWAIT, SnowflakeParserWAREHOUSE, SnowflakeParserWAREHOUSES, SnowflakeParserWAREHOUSE_SIZE, SnowflakeParserWEEKLY, SnowflakeParserWEEK_OF_YEAR_POLICY, SnowflakeParserWEEK_START, SnowflakeParserWELL_FORMED_XML, SnowflakeParserWITHIN, SnowflakeParserWITHOUT, SnowflakeParserWITHOUT_ARRAY_WRAPPER, SnowflakeParserWORK, SnowflakeParserWORKLOAD, SnowflakeParserWRITE, SnowflakeParserXLARGE, SnowflakeParserXLOCK, SnowflakeParserXML, SnowflakeParserXML_Q, SnowflakeParserXSMALL, SnowflakeParserXXLARGE, SnowflakeParserXXXLARGE, SnowflakeParserYEARLY, SnowflakeParserZSTD, SnowflakeParserARRAY, SnowflakeParserARRAY_Q, SnowflakeParserBIGINT, SnowflakeParserBINARY, SnowflakeParserBOOLEAN, SnowflakeParserBYTEINT, SnowflakeParserCHAR_VARYING, SnowflakeParserDATE, SnowflakeParserDATETIME, SnowflakeParserDECIMAL_, SnowflakeParserFLOAT4, SnowflakeParserFLOAT8, SnowflakeParserFLOAT_, SnowflakeParserGEOGRAPHY, SnowflakeParserGEOMETRY, SnowflakeParserINTEGER, SnowflakeParserNCHAR_VARYING, SnowflakeParserNUMERIC, SnowflakeParserNVARCHAR, SnowflakeParserREAL_, SnowflakeParserSMALLINT, SnowflakeParserSTRING_, SnowflakeParserTEXT, SnowflakeParserTINYINT, SnowflakeParserVARBINARY, SnowflakeParserVARCHAR, SnowflakeParserVARIANT, SnowflakeParserLISTAGG, SnowflakeParserDUMMY, SnowflakeParserDOUBLE_QUOTE_ID, SnowflakeParserDOUBLE_QUOTE_BLANK, SnowflakeParserID, SnowflakeParserID2, SnowflakeParserRR_BRACKET, SnowflakeParserSEMI: + p.SetState(10435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSCHEMA { + { + p.SetState(10434) + p.Match(SnowflakeParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10438) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1344, p.GetParserRuleContext()) == 1 { + { + p.SetState(10437) + p.Schema_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(10445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserSTARTS { + { + p.SetState(10444) + p.Starts_with() + } + + } + p.SetState(10448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIMIT { + { + p.SetState(10447) + p.Limit_rows() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IShow_warehousesContext is an interface to support dynamic dispatch. +type IShow_warehousesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + WAREHOUSES() antlr.TerminalNode + Like_pattern() ILike_patternContext + + // IsShow_warehousesContext differentiates from other interfaces. + IsShow_warehousesContext() +} + +type Show_warehousesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShow_warehousesContext() *Show_warehousesContext { + var p = new(Show_warehousesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_warehouses + return p +} + +func InitEmptyShow_warehousesContext(p *Show_warehousesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_show_warehouses +} + +func (*Show_warehousesContext) IsShow_warehousesContext() {} + +func NewShow_warehousesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Show_warehousesContext { + var p = new(Show_warehousesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_show_warehouses + + return p +} + +func (s *Show_warehousesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Show_warehousesContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Show_warehousesContext) WAREHOUSES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSES, 0) +} + +func (s *Show_warehousesContext) Like_pattern() ILike_patternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILike_patternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILike_patternContext) +} + +func (s *Show_warehousesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Show_warehousesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Show_warehousesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterShow_warehouses(s) + } +} + +func (s *Show_warehousesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitShow_warehouses(s) + } +} + +func (s *Show_warehousesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitShow_warehouses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Show_warehouses() (localctx IShow_warehousesContext) { + localctx = NewShow_warehousesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 828, SnowflakeParserRULE_show_warehouses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10450) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10451) + p.Match(SnowflakeParserWAREHOUSES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLIKE { + { + p.SetState(10452) + p.Like_pattern() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILike_patternContext is an interface to support dynamic dispatch. +type ILike_patternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LIKE() antlr.TerminalNode + String_() IStringContext + + // IsLike_patternContext differentiates from other interfaces. + IsLike_patternContext() +} + +type Like_patternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLike_patternContext() *Like_patternContext { + var p = new(Like_patternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_like_pattern + return p +} + +func InitEmptyLike_patternContext(p *Like_patternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_like_pattern +} + +func (*Like_patternContext) IsLike_patternContext() {} + +func NewLike_patternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Like_patternContext { + var p = new(Like_patternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_like_pattern + + return p +} + +func (s *Like_patternContext) GetParser() antlr.Parser { return s.parser } + +func (s *Like_patternContext) LIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIKE, 0) +} + +func (s *Like_patternContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Like_patternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Like_patternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Like_patternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterLike_pattern(s) + } +} + +func (s *Like_patternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitLike_pattern(s) + } +} + +func (s *Like_patternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitLike_pattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Like_pattern() (localctx ILike_patternContext) { + localctx = NewLike_patternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 830, SnowflakeParserRULE_like_pattern) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10455) + p.Match(SnowflakeParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10456) + p.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 +} + +// IAccount_identifierContext is an interface to support dynamic dispatch. +type IAccount_identifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + + // IsAccount_identifierContext differentiates from other interfaces. + IsAccount_identifierContext() +} + +type Account_identifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccount_identifierContext() *Account_identifierContext { + var p = new(Account_identifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_identifier + return p +} + +func InitEmptyAccount_identifierContext(p *Account_identifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_account_identifier +} + +func (*Account_identifierContext) IsAccount_identifierContext() {} + +func NewAccount_identifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Account_identifierContext { + var p = new(Account_identifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_account_identifier + + return p +} + +func (s *Account_identifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *Account_identifierContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Account_identifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Account_identifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Account_identifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAccount_identifier(s) + } +} + +func (s *Account_identifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAccount_identifier(s) + } +} + +func (s *Account_identifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAccount_identifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Account_identifier() (localctx IAccount_identifierContext) { + localctx = NewAccount_identifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 832, SnowflakeParserRULE_account_identifier) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10458) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_nameContext is an interface to support dynamic dispatch. +type ISchema_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + DOT() antlr.TerminalNode + + // IsSchema_nameContext differentiates from other interfaces. + IsSchema_nameContext() +} + +type Schema_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_nameContext() *Schema_nameContext { + var p = new(Schema_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_name + return p +} + +func InitEmptySchema_nameContext(p *Schema_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_schema_name +} + +func (*Schema_nameContext) IsSchema_nameContext() {} + +func NewSchema_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_nameContext { + var p = new(Schema_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_schema_name + + return p +} + +func (s *Schema_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_nameContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Schema_nameContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Schema_nameContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *Schema_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSchema_name(s) + } +} + +func (s *Schema_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSchema_name(s) + } +} + +func (s *Schema_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSchema_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Schema_name() (localctx ISchema_nameContext) { + localctx = NewSchema_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 834, SnowflakeParserRULE_schema_name) + p.SetState(10465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1350, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10460) + p.Id_() + } + { + p.SetState(10461) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10462) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10464) + p.Id_() + } + + 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_typeContext is an interface to support dynamic dispatch. +type IObject_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACCOUNT() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + DATABASES() antlr.TerminalNode + INTEGRATIONS() antlr.TerminalNode + NETWORK() antlr.TerminalNode + POLICIES() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + MONITORS() antlr.TerminalNode + ROLES() antlr.TerminalNode + SHARES() antlr.TerminalNode + USERS() antlr.TerminalNode + WAREHOUSES() antlr.TerminalNode + + // IsObject_typeContext differentiates from other interfaces. + IsObject_typeContext() +} + +type Object_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_typeContext() *Object_typeContext { + var p = new(Object_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_type + return p +} + +func InitEmptyObject_typeContext(p *Object_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_type +} + +func (*Object_typeContext) IsObject_typeContext() {} + +func NewObject_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_typeContext { + var p = new(Object_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_object_type + + return p +} + +func (s *Object_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_typeContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNT, 0) +} + +func (s *Object_typeContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARAMETERS, 0) +} + +func (s *Object_typeContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Object_typeContext) INTEGRATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATIONS, 0) +} + +func (s *Object_typeContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Object_typeContext) POLICIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICIES, 0) +} + +func (s *Object_typeContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE, 0) +} + +func (s *Object_typeContext) MONITORS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITORS, 0) +} + +func (s *Object_typeContext) ROLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLES, 0) +} + +func (s *Object_typeContext) SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARES, 0) +} + +func (s *Object_typeContext) USERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSERS, 0) +} + +func (s *Object_typeContext) WAREHOUSES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSES, 0) +} + +func (s *Object_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterObject_type(s) + } +} + +func (s *Object_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_type(s) + } +} + +func (s *Object_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_type() (localctx IObject_typeContext) { + localctx = NewObject_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 836, SnowflakeParserRULE_object_type) + p.SetState(10479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserACCOUNT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10467) + p.Match(SnowflakeParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10468) + p.Match(SnowflakeParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATABASES: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10469) + p.Match(SnowflakeParserDATABASES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserINTEGRATIONS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10470) + p.Match(SnowflakeParserINTEGRATIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNETWORK: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10471) + p.Match(SnowflakeParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10472) + p.Match(SnowflakeParserPOLICIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRESOURCE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10473) + p.Match(SnowflakeParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10474) + p.Match(SnowflakeParserMONITORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserROLES: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10475) + p.Match(SnowflakeParserROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSHARES: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10476) + p.Match(SnowflakeParserSHARES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUSERS: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10477) + p.Match(SnowflakeParserUSERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserWAREHOUSES: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10478) + p.Match(SnowflakeParserWAREHOUSES) + 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_listContext is an interface to support dynamic dispatch. +type IObject_type_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllObject_type() []IObject_typeContext + Object_type(i int) IObject_typeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsObject_type_listContext differentiates from other interfaces. + IsObject_type_listContext() +} + +type Object_type_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_type_listContext() *Object_type_listContext { + var p = new(Object_type_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_type_list + return p +} + +func InitEmptyObject_type_listContext(p *Object_type_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_type_list +} + +func (*Object_type_listContext) IsObject_type_listContext() {} + +func NewObject_type_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_listContext { + var p = new(Object_type_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_object_type_list + + return p +} + +func (s *Object_type_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_listContext) AllObject_type() []IObject_typeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_typeContext); ok { + len++ + } + } + + tst := make([]IObject_typeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_typeContext); ok { + tst[i] = t.(IObject_typeContext) + i++ + } + } + + return tst +} + +func (s *Object_type_listContext) Object_type(i int) IObject_typeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_typeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_typeContext) +} + +func (s *Object_type_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Object_type_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Object_type_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterObject_type_list(s) + } +} + +func (s *Object_type_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_type_list(s) + } +} + +func (s *Object_type_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_type_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_type_list() (localctx IObject_type_listContext) { + localctx = NewObject_type_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 838, SnowflakeParserRULE_object_type_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10481) + p.Object_type() + } + p.SetState(10486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10482) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10483) + p.Object_type() + } + + p.SetState(10488) + 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 +} + +// ITag_valueContext is an interface to support dynamic dispatch. +type ITag_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + String_() IStringContext + + // IsTag_valueContext differentiates from other interfaces. + IsTag_valueContext() +} + +type Tag_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTag_valueContext() *Tag_valueContext { + var p = new(Tag_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_tag_value + return p +} + +func InitEmptyTag_valueContext(p *Tag_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_tag_value +} + +func (*Tag_valueContext) IsTag_valueContext() {} + +func NewTag_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tag_valueContext { + var p = new(Tag_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_tag_value + + return p +} + +func (s *Tag_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tag_valueContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Tag_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tag_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tag_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTag_value(s) + } +} + +func (s *Tag_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTag_value(s) + } +} + +func (s *Tag_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTag_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Tag_value() (localctx ITag_valueContext) { + localctx = NewTag_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 840, SnowflakeParserRULE_tag_value) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10489) + p.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 +} + +// IArg_data_typeContext is an interface to support dynamic dispatch. +type IArg_data_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + + // IsArg_data_typeContext differentiates from other interfaces. + IsArg_data_typeContext() +} + +type Arg_data_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArg_data_typeContext() *Arg_data_typeContext { + var p = new(Arg_data_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arg_data_type + return p +} + +func InitEmptyArg_data_typeContext(p *Arg_data_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arg_data_type +} + +func (*Arg_data_typeContext) IsArg_data_typeContext() {} + +func NewArg_data_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arg_data_typeContext { + var p = new(Arg_data_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_arg_data_type + + return p +} + +func (s *Arg_data_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Arg_data_typeContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Arg_data_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Arg_data_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Arg_data_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterArg_data_type(s) + } +} + +func (s *Arg_data_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitArg_data_type(s) + } +} + +func (s *Arg_data_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitArg_data_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Arg_data_type() (localctx IArg_data_typeContext) { + localctx = NewArg_data_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 842, SnowflakeParserRULE_arg_data_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10491) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_nameContext is an interface to support dynamic dispatch. +type IArg_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + + // IsArg_nameContext differentiates from other interfaces. + IsArg_nameContext() +} + +type Arg_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArg_nameContext() *Arg_nameContext { + var p = new(Arg_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arg_name + return p +} + +func InitEmptyArg_nameContext(p *Arg_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arg_name +} + +func (*Arg_nameContext) IsArg_nameContext() {} + +func NewArg_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arg_nameContext { + var p = new(Arg_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_arg_name + + return p +} + +func (s *Arg_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Arg_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Arg_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Arg_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Arg_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterArg_name(s) + } +} + +func (s *Arg_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitArg_name(s) + } +} + +func (s *Arg_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitArg_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Arg_name() (localctx IArg_nameContext) { + localctx = NewArg_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 844, SnowflakeParserRULE_arg_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10493) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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 + Id_() IId_Context + + // 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 = SnowflakeParserRULE_param_name + return p +} + +func InitEmptyParam_nameContext(p *Param_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_param_name + + return p +} + +func (s *Param_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Param_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +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.(SnowflakeParserListener); ok { + listenerT.EnterParam_name(s) + } +} + +func (s *Param_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitParam_name(s) + } +} + +func (s *Param_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitParam_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Param_name() (localctx IParam_nameContext) { + localctx = NewParam_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 846, SnowflakeParserRULE_param_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10495) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRegion_group_idContext is an interface to support dynamic dispatch. +type IRegion_group_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + + // IsRegion_group_idContext differentiates from other interfaces. + IsRegion_group_idContext() +} + +type Region_group_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRegion_group_idContext() *Region_group_idContext { + var p = new(Region_group_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_region_group_id + return p +} + +func InitEmptyRegion_group_idContext(p *Region_group_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_region_group_id +} + +func (*Region_group_idContext) IsRegion_group_idContext() {} + +func NewRegion_group_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Region_group_idContext { + var p = new(Region_group_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_region_group_id + + return p +} + +func (s *Region_group_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Region_group_idContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Region_group_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Region_group_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Region_group_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRegion_group_id(s) + } +} + +func (s *Region_group_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRegion_group_id(s) + } +} + +func (s *Region_group_idContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRegion_group_id(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Region_group_id() (localctx IRegion_group_idContext) { + localctx = NewRegion_group_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 848, SnowflakeParserRULE_region_group_id) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10497) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISnowflake_region_idContext is an interface to support dynamic dispatch. +type ISnowflake_region_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + + // IsSnowflake_region_idContext differentiates from other interfaces. + IsSnowflake_region_idContext() +} + +type Snowflake_region_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySnowflake_region_idContext() *Snowflake_region_idContext { + var p = new(Snowflake_region_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_snowflake_region_id + return p +} + +func InitEmptySnowflake_region_idContext(p *Snowflake_region_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_snowflake_region_id +} + +func (*Snowflake_region_idContext) IsSnowflake_region_idContext() {} + +func NewSnowflake_region_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Snowflake_region_idContext { + var p = new(Snowflake_region_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_snowflake_region_id + + return p +} + +func (s *Snowflake_region_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Snowflake_region_idContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Snowflake_region_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Snowflake_region_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Snowflake_region_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSnowflake_region_id(s) + } +} + +func (s *Snowflake_region_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSnowflake_region_id(s) + } +} + +func (s *Snowflake_region_idContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSnowflake_region_id(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Snowflake_region_id() (localctx ISnowflake_region_idContext) { + localctx = NewSnowflake_region_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 850, SnowflakeParserRULE_snowflake_region_id) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10499) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStringContext is an interface to support dynamic dispatch. +type IStringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING() antlr.TerminalNode + + // IsStringContext differentiates from other interfaces. + IsStringContext() +} + +type StringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStringContext() *StringContext { + var p = new(StringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_string + return p +} + +func InitEmptyStringContext(p *StringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_string +} + +func (*StringContext) IsStringContext() {} + +func NewStringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringContext { + var p = new(StringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_string + + return p +} + +func (s *StringContext) GetParser() antlr.Parser { return s.parser } + +func (s *StringContext) STRING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING, 0) +} + +func (s *StringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterString(s) + } +} + +func (s *StringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitString(s) + } +} + +func (s *StringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitString(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) String_() (localctx IStringContext) { + localctx = NewStringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 852, SnowflakeParserRULE_string) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10501) + p.Match(SnowflakeParserSTRING) + 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 +} + +// IString_listContext is an interface to support dynamic dispatch. +type IString_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllString_() []IStringContext + String_(i int) IStringContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsString_listContext differentiates from other interfaces. + IsString_listContext() +} + +type String_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_listContext() *String_listContext { + var p = new(String_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_string_list + return p +} + +func InitEmptyString_listContext(p *String_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_string_list +} + +func (*String_listContext) IsString_listContext() {} + +func NewString_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_listContext { + var p = new(String_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_string_list + + return p +} + +func (s *String_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_listContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *String_listContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *String_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *String_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *String_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterString_list(s) + } +} + +func (s *String_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitString_list(s) + } +} + +func (s *String_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitString_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) String_list() (localctx IString_listContext) { + localctx = NewString_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 854, SnowflakeParserRULE_string_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10503) + p.String_() + } + p.SetState(10508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10504) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10505) + p.String_() + } + + p.SetState(10510) + 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 +} + +// IId_Context is an interface to support dynamic dispatch. +type IId_Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ID() antlr.TerminalNode + ID2() antlr.TerminalNode + DOUBLE_QUOTE_ID() antlr.TerminalNode + DOUBLE_QUOTE_BLANK() antlr.TerminalNode + Keyword() IKeywordContext + Non_reserved_words() INon_reserved_wordsContext + Data_type() IData_typeContext + Builtin_function() IBuiltin_functionContext + ALERT() antlr.TerminalNode + ALERTS() antlr.TerminalNode + CONDITION() antlr.TerminalNode + Supplement_non_reserved_words() ISupplement_non_reserved_wordsContext + + // IsId_Context differentiates from other interfaces. + IsId_Context() +} + +type Id_Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyId_Context() *Id_Context { + var p = new(Id_Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_id_ + return p +} + +func InitEmptyId_Context(p *Id_Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_id_ +} + +func (*Id_Context) IsId_Context() {} + +func NewId_Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Id_Context { + var p = new(Id_Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_id_ + + return p +} + +func (s *Id_Context) GetParser() antlr.Parser { return s.parser } + +func (s *Id_Context) ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserID, 0) +} + +func (s *Id_Context) ID2() antlr.TerminalNode { + return s.GetToken(SnowflakeParserID2, 0) +} + +func (s *Id_Context) DOUBLE_QUOTE_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOUBLE_QUOTE_ID, 0) +} + +func (s *Id_Context) DOUBLE_QUOTE_BLANK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOUBLE_QUOTE_BLANK, 0) +} + +func (s *Id_Context) Keyword() IKeywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeywordContext) +} + +func (s *Id_Context) Non_reserved_words() INon_reserved_wordsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_reserved_wordsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INon_reserved_wordsContext) +} + +func (s *Id_Context) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Id_Context) Builtin_function() IBuiltin_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuiltin_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuiltin_functionContext) +} + +func (s *Id_Context) ALERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERT, 0) +} + +func (s *Id_Context) ALERTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERTS, 0) +} + +func (s *Id_Context) CONDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONDITION, 0) +} + +func (s *Id_Context) Supplement_non_reserved_words() ISupplement_non_reserved_wordsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplement_non_reserved_wordsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplement_non_reserved_wordsContext) +} + +func (s *Id_Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Id_Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Id_Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterId_(s) + } +} + +func (s *Id_Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitId_(s) + } +} + +func (s *Id_Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitId_(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Id_() (localctx IId_Context) { + localctx = NewId_Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 856, SnowflakeParserRULE_id_) + p.SetState(10523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1354, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10511) + p.Match(SnowflakeParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10512) + p.Match(SnowflakeParserID2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10513) + p.Match(SnowflakeParserDOUBLE_QUOTE_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10514) + p.Match(SnowflakeParserDOUBLE_QUOTE_BLANK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10515) + p.Keyword() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10516) + p.Non_reserved_words() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10517) + p.Data_type() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10518) + p.Builtin_function() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10519) + p.Match(SnowflakeParserALERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(10520) + p.Match(SnowflakeParserALERTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(10521) + p.Match(SnowflakeParserCONDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(10522) + p.Supplement_non_reserved_words() + } + + 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 +} + +// IKeywordContext is an interface to support dynamic dispatch. +type IKeywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INT() antlr.TerminalNode + BIGINT() antlr.TerminalNode + STAGE() antlr.TerminalNode + USER() antlr.TerminalNode + TYPE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + TEMP() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + REGION() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + AT_KEYWORD() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + IF() antlr.TerminalNode + COPY_OPTIONS_() antlr.TerminalNode + + // IsKeywordContext differentiates from other interfaces. + IsKeywordContext() +} + +type KeywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeywordContext() *KeywordContext { + var p = new(KeywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_keyword + return p +} + +func InitEmptyKeywordContext(p *KeywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_keyword +} + +func (*KeywordContext) IsKeywordContext() {} + +func NewKeywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *KeywordContext { + var p = new(KeywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_keyword + + return p +} + +func (s *KeywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *KeywordContext) INT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINT, 0) +} + +func (s *KeywordContext) BIGINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBIGINT, 0) +} + +func (s *KeywordContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *KeywordContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *KeywordContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *KeywordContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTER, 0) +} + +func (s *KeywordContext) TEMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEMP, 0) +} + +func (s *KeywordContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *KeywordContext) REGION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREGION, 0) +} + +func (s *KeywordContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLLUP, 0) +} + +func (s *KeywordContext) AT_KEYWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAT_KEYWORD, 0) +} + +func (s *KeywordContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP, 0) +} + +func (s *KeywordContext) IF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIF, 0) +} + +func (s *KeywordContext) COPY_OPTIONS_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY_OPTIONS_, 0) +} + +func (s *KeywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *KeywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *KeywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterKeyword(s) + } +} + +func (s *KeywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitKeyword(s) + } +} + +func (s *KeywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitKeyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Keyword() (localctx IKeywordContext) { + localctx = NewKeywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 858, SnowflakeParserRULE_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10525) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAT_KEYWORD || _la == SnowflakeParserCLUSTER || _la == SnowflakeParserCOPY_OPTIONS_ || ((int64((_la-331)) & ^0x3f) == 0 && ((int64(1)<<(_la-331))&4611686027017322497) != 0) || _la == SnowflakeParserREGION || _la == SnowflakeParserROLLUP || _la == SnowflakeParserSTAGE || ((int64((_la-893)) & ^0x3f) == 0 && ((int64(1)<<(_la-893))&2305843009213696001) != 0) || _la == SnowflakeParserUSER || _la == SnowflakeParserBIGINT) { + 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 +} + +// INon_reserved_wordsContext is an interface to support dynamic dispatch. +type INon_reserved_wordsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORGADMIN() antlr.TerminalNode + ACCOUNTADMIN() antlr.TerminalNode + SECURITYADMIN() antlr.TerminalNode + USERADMIN() antlr.TerminalNode + SYSADMIN() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + JAVASCRIPT() antlr.TerminalNode + RESULT() antlr.TerminalNode + INDEX() antlr.TerminalNode + SOURCE() antlr.TerminalNode + PROCEDURE_NAME() antlr.TerminalNode + STATE() antlr.TerminalNode + ROLE() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + LOCAL() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + VALUE() antlr.TerminalNode + NAME() antlr.TerminalNode + TAG() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + VERSION() antlr.TerminalNode + OPTION() antlr.TerminalNode + + // IsNon_reserved_wordsContext differentiates from other interfaces. + IsNon_reserved_wordsContext() +} + +type Non_reserved_wordsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_reserved_wordsContext() *Non_reserved_wordsContext { + var p = new(Non_reserved_wordsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_non_reserved_words + return p +} + +func InitEmptyNon_reserved_wordsContext(p *Non_reserved_wordsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_non_reserved_words +} + +func (*Non_reserved_wordsContext) IsNon_reserved_wordsContext() {} + +func NewNon_reserved_wordsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_reserved_wordsContext { + var p = new(Non_reserved_wordsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_non_reserved_words + + return p +} + +func (s *Non_reserved_wordsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_reserved_wordsContext) ORGADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORGADMIN, 0) +} + +func (s *Non_reserved_wordsContext) ACCOUNTADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTADMIN, 0) +} + +func (s *Non_reserved_wordsContext) SECURITYADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITYADMIN, 0) +} + +func (s *Non_reserved_wordsContext) USERADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSERADMIN, 0) +} + +func (s *Non_reserved_wordsContext) SYSADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYSADMIN, 0) +} + +func (s *Non_reserved_wordsContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPUBLIC, 0) +} + +func (s *Non_reserved_wordsContext) JAVASCRIPT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJAVASCRIPT, 0) +} + +func (s *Non_reserved_wordsContext) RESULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESULT, 0) +} + +func (s *Non_reserved_wordsContext) INDEX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINDEX, 0) +} + +func (s *Non_reserved_wordsContext) SOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSOURCE, 0) +} + +func (s *Non_reserved_wordsContext) PROCEDURE_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE_NAME, 0) +} + +func (s *Non_reserved_wordsContext) STATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATE, 0) +} + +func (s *Non_reserved_wordsContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Non_reserved_wordsContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFINITION, 0) +} + +func (s *Non_reserved_wordsContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEZONE, 0) +} + +func (s *Non_reserved_wordsContext) LOCAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCAL, 0) +} + +func (s *Non_reserved_wordsContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW_NUMBER, 0) +} + +func (s *Non_reserved_wordsContext) VALUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALUE, 0) +} + +func (s *Non_reserved_wordsContext) NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNAME, 0) +} + +func (s *Non_reserved_wordsContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Non_reserved_wordsContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Non_reserved_wordsContext) VERSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVERSION, 0) +} + +func (s *Non_reserved_wordsContext) OPTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPTION, 0) +} + +func (s *Non_reserved_wordsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_reserved_wordsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_reserved_wordsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterNon_reserved_words(s) + } +} + +func (s *Non_reserved_wordsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitNon_reserved_words(s) + } +} + +func (s *Non_reserved_wordsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitNon_reserved_words(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Non_reserved_words() (localctx INon_reserved_wordsContext) { + localctx = NewNon_reserved_wordsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 860, SnowflakeParserRULE_non_reserved_words) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10527) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserACCOUNTADMIN || _la == SnowflakeParserDEFINITION || ((int64((_la-382)) & ^0x3f) == 0 && ((int64(1)<<(_la-382))&72057594038976513) != 0) || _la == SnowflakeParserNAME || _la == SnowflakeParserOPTION || _la == SnowflakeParserORGADMIN || _la == SnowflakeParserPROCEDURE_NAME || _la == SnowflakeParserPUBLIC || ((int64((_la-702)) & ^0x3f) == 0 && ((int64(1)<<(_la-702))&134283265) != 0) || ((int64((_la-771)) & ^0x3f) == 0 && ((int64(1)<<(_la-771))&4611690416473899009) != 0) || ((int64((_la-877)) & ^0x3f) == 0 && ((int64(1)<<(_la-877))&2199023256577) != 0) || ((int64((_la-985)) & ^0x3f) == 0 && ((int64(1)<<(_la-985))&67641345) != 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 +} + +// IBuiltin_functionContext is an interface to support dynamic dispatch. +type IBuiltin_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IFF() antlr.TerminalNode + SUM() antlr.TerminalNode + AVG() antlr.TerminalNode + MIN() antlr.TerminalNode + COUNT() antlr.TerminalNode + CURRENT_TIMESTAMP() antlr.TerminalNode + CURRENT_DATE() antlr.TerminalNode + UPPER() antlr.TerminalNode + LOWER() antlr.TerminalNode + TO_BOOLEAN() antlr.TerminalNode + + // IsBuiltin_functionContext differentiates from other interfaces. + IsBuiltin_functionContext() +} + +type Builtin_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBuiltin_functionContext() *Builtin_functionContext { + var p = new(Builtin_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_builtin_function + return p +} + +func InitEmptyBuiltin_functionContext(p *Builtin_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_builtin_function +} + +func (*Builtin_functionContext) IsBuiltin_functionContext() {} + +func NewBuiltin_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Builtin_functionContext { + var p = new(Builtin_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_builtin_function + + return p +} + +func (s *Builtin_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Builtin_functionContext) IFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIFF, 0) +} + +func (s *Builtin_functionContext) SUM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUM, 0) +} + +func (s *Builtin_functionContext) AVG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVG, 0) +} + +func (s *Builtin_functionContext) MIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMIN, 0) +} + +func (s *Builtin_functionContext) COUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOUNT, 0) +} + +func (s *Builtin_functionContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCURRENT_TIMESTAMP, 0) +} + +func (s *Builtin_functionContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCURRENT_DATE, 0) +} + +func (s *Builtin_functionContext) UPPER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUPPER, 0) +} + +func (s *Builtin_functionContext) LOWER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOWER, 0) +} + +func (s *Builtin_functionContext) TO_BOOLEAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO_BOOLEAN, 0) +} + +func (s *Builtin_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Builtin_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Builtin_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterBuiltin_function(s) + } +} + +func (s *Builtin_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitBuiltin_function(s) + } +} + +func (s *Builtin_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitBuiltin_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Builtin_function() (localctx IBuiltin_functionContext) { + localctx = NewBuiltin_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 862, SnowflakeParserRULE_builtin_function) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10529) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAVG || ((int64((_la-188)) & ^0x3f) == 0 && ((int64(1)<<(_la-188))&10241) != 0) || _la == SnowflakeParserIFF || _la == SnowflakeParserLOWER || _la == SnowflakeParserMIN || _la == SnowflakeParserSUM || _la == SnowflakeParserTO_BOOLEAN || _la == SnowflakeParserUPPER) { + 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 +} + +// IList_operatorContext is an interface to support dynamic dispatch. +type IList_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONCAT() antlr.TerminalNode + CONCAT_WS() antlr.TerminalNode + COALESCE() antlr.TerminalNode + + // IsList_operatorContext differentiates from other interfaces. + IsList_operatorContext() +} + +type List_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_operatorContext() *List_operatorContext { + var p = new(List_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_list_operator + return p +} + +func InitEmptyList_operatorContext(p *List_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_list_operator +} + +func (*List_operatorContext) IsList_operatorContext() {} + +func NewList_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_operatorContext { + var p = new(List_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_list_operator + + return p +} + +func (s *List_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_operatorContext) CONCAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONCAT, 0) +} + +func (s *List_operatorContext) CONCAT_WS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONCAT_WS, 0) +} + +func (s *List_operatorContext) COALESCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOALESCE, 0) +} + +func (s *List_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterList_operator(s) + } +} + +func (s *List_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitList_operator(s) + } +} + +func (s *List_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitList_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) List_operator() (localctx IList_operatorContext) { + localctx = NewList_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 864, SnowflakeParserRULE_list_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10531) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-154)) & ^0x3f) == 0 && ((int64(1)<<(_la-154))&20481) != 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 +} + +// IBinary_builtin_functionContext is an interface to support dynamic dispatch. +type IBinary_builtin_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIfnull returns the ifnull token. + GetIfnull() antlr.Token + + // GetTo_date returns the to_date token. + GetTo_date() antlr.Token + + // SetIfnull sets the ifnull token. + SetIfnull(antlr.Token) + + // SetTo_date sets the to_date token. + SetTo_date(antlr.Token) + + // Getter signatures + IFNULL() antlr.TerminalNode + NVL() antlr.TerminalNode + GET() antlr.TerminalNode + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + DATE_PART() antlr.TerminalNode + TO_DATE() antlr.TerminalNode + DATE() antlr.TerminalNode + SPLIT() antlr.TerminalNode + + // IsBinary_builtin_functionContext differentiates from other interfaces. + IsBinary_builtin_functionContext() +} + +type Binary_builtin_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ifnull antlr.Token + to_date antlr.Token +} + +func NewEmptyBinary_builtin_functionContext() *Binary_builtin_functionContext { + var p = new(Binary_builtin_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_binary_builtin_function + return p +} + +func InitEmptyBinary_builtin_functionContext(p *Binary_builtin_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_binary_builtin_function +} + +func (*Binary_builtin_functionContext) IsBinary_builtin_functionContext() {} + +func NewBinary_builtin_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Binary_builtin_functionContext { + var p = new(Binary_builtin_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_binary_builtin_function + + return p +} + +func (s *Binary_builtin_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Binary_builtin_functionContext) GetIfnull() antlr.Token { return s.ifnull } + +func (s *Binary_builtin_functionContext) GetTo_date() antlr.Token { return s.to_date } + +func (s *Binary_builtin_functionContext) SetIfnull(v antlr.Token) { s.ifnull = v } + +func (s *Binary_builtin_functionContext) SetTo_date(v antlr.Token) { s.to_date = v } + +func (s *Binary_builtin_functionContext) IFNULL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIFNULL, 0) +} + +func (s *Binary_builtin_functionContext) NVL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNVL, 0) +} + +func (s *Binary_builtin_functionContext) GET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGET, 0) +} + +func (s *Binary_builtin_functionContext) LEFT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLEFT, 0) +} + +func (s *Binary_builtin_functionContext) RIGHT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRIGHT, 0) +} + +func (s *Binary_builtin_functionContext) DATE_PART() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_PART, 0) +} + +func (s *Binary_builtin_functionContext) TO_DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO_DATE, 0) +} + +func (s *Binary_builtin_functionContext) DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE, 0) +} + +func (s *Binary_builtin_functionContext) SPLIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSPLIT, 0) +} + +func (s *Binary_builtin_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Binary_builtin_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Binary_builtin_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterBinary_builtin_function(s) + } +} + +func (s *Binary_builtin_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitBinary_builtin_function(s) + } +} + +func (s *Binary_builtin_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitBinary_builtin_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Binary_builtin_function() (localctx IBinary_builtin_functionContext) { + localctx = NewBinary_builtin_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 866, SnowflakeParserRULE_binary_builtin_function) + var _la int + + p.SetState(10540) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserIFNULL, SnowflakeParserNVL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10533) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Binary_builtin_functionContext).ifnull = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserIFNULL || _la == SnowflakeParserNVL) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Binary_builtin_functionContext).ifnull = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserGET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10534) + p.Match(SnowflakeParserGET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserLEFT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10535) + p.Match(SnowflakeParserLEFT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserRIGHT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10536) + p.Match(SnowflakeParserRIGHT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATE_PART: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10537) + p.Match(SnowflakeParserDATE_PART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTO_DATE, SnowflakeParserDATE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10538) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Binary_builtin_functionContext).to_date = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserTO_DATE || _la == SnowflakeParserDATE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Binary_builtin_functionContext).to_date = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserSPLIT: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10539) + p.Match(SnowflakeParserSPLIT) + 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 +} + +// IBinary_or_ternary_builtin_functionContext is an interface to support dynamic dispatch. +type IBinary_or_ternary_builtin_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSubstring returns the substring token. + GetSubstring() antlr.Token + + // SetSubstring sets the substring token. + SetSubstring(antlr.Token) + + // Getter signatures + CHARINDEX() antlr.TerminalNode + REPLACE() antlr.TerminalNode + SUBSTRING() antlr.TerminalNode + SUBSTR() antlr.TerminalNode + LIKE() antlr.TerminalNode + ILIKE() antlr.TerminalNode + + // IsBinary_or_ternary_builtin_functionContext differentiates from other interfaces. + IsBinary_or_ternary_builtin_functionContext() +} + +type Binary_or_ternary_builtin_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + substring antlr.Token +} + +func NewEmptyBinary_or_ternary_builtin_functionContext() *Binary_or_ternary_builtin_functionContext { + var p = new(Binary_or_ternary_builtin_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_binary_or_ternary_builtin_function + return p +} + +func InitEmptyBinary_or_ternary_builtin_functionContext(p *Binary_or_ternary_builtin_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_binary_or_ternary_builtin_function +} + +func (*Binary_or_ternary_builtin_functionContext) IsBinary_or_ternary_builtin_functionContext() {} + +func NewBinary_or_ternary_builtin_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Binary_or_ternary_builtin_functionContext { + var p = new(Binary_or_ternary_builtin_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_binary_or_ternary_builtin_function + + return p +} + +func (s *Binary_or_ternary_builtin_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Binary_or_ternary_builtin_functionContext) GetSubstring() antlr.Token { return s.substring } + +func (s *Binary_or_ternary_builtin_functionContext) SetSubstring(v antlr.Token) { s.substring = v } + +func (s *Binary_or_ternary_builtin_functionContext) CHARINDEX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHARINDEX, 0) +} + +func (s *Binary_or_ternary_builtin_functionContext) REPLACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLACE, 0) +} + +func (s *Binary_or_ternary_builtin_functionContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUBSTRING, 0) +} + +func (s *Binary_or_ternary_builtin_functionContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUBSTR, 0) +} + +func (s *Binary_or_ternary_builtin_functionContext) LIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIKE, 0) +} + +func (s *Binary_or_ternary_builtin_functionContext) ILIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserILIKE, 0) +} + +func (s *Binary_or_ternary_builtin_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Binary_or_ternary_builtin_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Binary_or_ternary_builtin_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterBinary_or_ternary_builtin_function(s) + } +} + +func (s *Binary_or_ternary_builtin_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitBinary_or_ternary_builtin_function(s) + } +} + +func (s *Binary_or_ternary_builtin_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitBinary_or_ternary_builtin_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Binary_or_ternary_builtin_function() (localctx IBinary_or_ternary_builtin_functionContext) { + localctx = NewBinary_or_ternary_builtin_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 868, SnowflakeParserRULE_binary_or_ternary_builtin_function) + var _la int + + p.SetState(10547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCHARINDEX: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10542) + p.Match(SnowflakeParserCHARINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserREPLACE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10543) + p.Match(SnowflakeParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSUBSTR, SnowflakeParserSUBSTRING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10544) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Binary_or_ternary_builtin_functionContext).substring = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserSUBSTR || _la == SnowflakeParserSUBSTRING) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Binary_or_ternary_builtin_functionContext).substring = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserLIKE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10545) + p.Match(SnowflakeParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserILIKE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10546) + p.Match(SnowflakeParserILIKE) + 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 +} + +// ITernary_builtin_functionContext is an interface to support dynamic dispatch. +type ITernary_builtin_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDateadd returns the dateadd token. + GetDateadd() antlr.Token + + // GetDatefiff returns the datefiff token. + GetDatefiff() antlr.Token + + // SetDateadd sets the dateadd token. + SetDateadd(antlr.Token) + + // SetDatefiff sets the datefiff token. + SetDatefiff(antlr.Token) + + // Getter signatures + DATEADD() antlr.TerminalNode + TIMEADD() antlr.TerminalNode + TIMESTAMPADD() antlr.TerminalNode + DATEDIFF() antlr.TerminalNode + TIMEDIFF() antlr.TerminalNode + TIMESTAMPDIFF() antlr.TerminalNode + SPLIT_PART() antlr.TerminalNode + + // IsTernary_builtin_functionContext differentiates from other interfaces. + IsTernary_builtin_functionContext() +} + +type Ternary_builtin_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dateadd antlr.Token + datefiff antlr.Token +} + +func NewEmptyTernary_builtin_functionContext() *Ternary_builtin_functionContext { + var p = new(Ternary_builtin_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ternary_builtin_function + return p +} + +func InitEmptyTernary_builtin_functionContext(p *Ternary_builtin_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ternary_builtin_function +} + +func (*Ternary_builtin_functionContext) IsTernary_builtin_functionContext() {} + +func NewTernary_builtin_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ternary_builtin_functionContext { + var p = new(Ternary_builtin_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_ternary_builtin_function + + return p +} + +func (s *Ternary_builtin_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ternary_builtin_functionContext) GetDateadd() antlr.Token { return s.dateadd } + +func (s *Ternary_builtin_functionContext) GetDatefiff() antlr.Token { return s.datefiff } + +func (s *Ternary_builtin_functionContext) SetDateadd(v antlr.Token) { s.dateadd = v } + +func (s *Ternary_builtin_functionContext) SetDatefiff(v antlr.Token) { s.datefiff = v } + +func (s *Ternary_builtin_functionContext) DATEADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATEADD, 0) +} + +func (s *Ternary_builtin_functionContext) TIMEADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEADD, 0) +} + +func (s *Ternary_builtin_functionContext) TIMESTAMPADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMPADD, 0) +} + +func (s *Ternary_builtin_functionContext) DATEDIFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATEDIFF, 0) +} + +func (s *Ternary_builtin_functionContext) TIMEDIFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEDIFF, 0) +} + +func (s *Ternary_builtin_functionContext) TIMESTAMPDIFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMPDIFF, 0) +} + +func (s *Ternary_builtin_functionContext) SPLIT_PART() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSPLIT_PART, 0) +} + +func (s *Ternary_builtin_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ternary_builtin_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ternary_builtin_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTernary_builtin_function(s) + } +} + +func (s *Ternary_builtin_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTernary_builtin_function(s) + } +} + +func (s *Ternary_builtin_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTernary_builtin_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Ternary_builtin_function() (localctx ITernary_builtin_functionContext) { + localctx = NewTernary_builtin_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 870, SnowflakeParserRULE_ternary_builtin_function) + var _la int + + p.SetState(10552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDATEADD, SnowflakeParserTIMEADD, SnowflakeParserTIMESTAMPADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10549) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Ternary_builtin_functionContext).dateadd = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDATEADD || _la == SnowflakeParserTIMEADD || _la == SnowflakeParserTIMESTAMPADD) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Ternary_builtin_functionContext).dateadd = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserDATEDIFF, SnowflakeParserTIMEDIFF, SnowflakeParserTIMESTAMPDIFF: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10550) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Ternary_builtin_functionContext).datefiff = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDATEDIFF || _la == SnowflakeParserTIMEDIFF || _la == SnowflakeParserTIMESTAMPDIFF) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Ternary_builtin_functionContext).datefiff = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserSPLIT_PART: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10551) + p.Match(SnowflakeParserSPLIT_PART) + 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 +} + +// IPatternContext is an interface to support dynamic dispatch. +type IPatternContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PATTERN() antlr.TerminalNode + EQ() antlr.TerminalNode + String_() IStringContext + + // IsPatternContext differentiates from other interfaces. + IsPatternContext() +} + +type PatternContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPatternContext() *PatternContext { + var p = new(PatternContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_pattern + return p +} + +func InitEmptyPatternContext(p *PatternContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_pattern +} + +func (*PatternContext) IsPatternContext() {} + +func NewPatternContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PatternContext { + var p = new(PatternContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_pattern + + return p +} + +func (s *PatternContext) GetParser() antlr.Parser { return s.parser } + +func (s *PatternContext) PATTERN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPATTERN, 0) +} + +func (s *PatternContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *PatternContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *PatternContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PatternContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PatternContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPattern(s) + } +} + +func (s *PatternContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPattern(s) + } +} + +func (s *PatternContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPattern(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Pattern() (localctx IPatternContext) { + localctx = NewPatternContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 872, SnowflakeParserRULE_pattern) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10554) + p.Match(SnowflakeParserPATTERN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10555) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10556) + p.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 +} + +// IColumn_nameContext is an interface to support dynamic dispatch. +type IColumn_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + + // IsColumn_nameContext differentiates from other interfaces. + IsColumn_nameContext() +} + +type Column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_nameContext() *Column_nameContext { + var p = new(Column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_name + return p +} + +func InitEmptyColumn_nameContext(p *Column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_name +} + +func (*Column_nameContext) IsColumn_nameContext() {} + +func NewColumn_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_nameContext { + var p = new(Column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_name + + return p +} + +func (s *Column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_nameContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_name(s) + } +} + +func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_name(s) + } +} + +func (s *Column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_name() (localctx IColumn_nameContext) { + localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 874, SnowflakeParserRULE_column_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10558) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_listContext is an interface to support dynamic dispatch. +type IColumn_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_listContext differentiates from other interfaces. + IsColumn_listContext() +} + +type Column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_listContext() *Column_listContext { + var p = new(Column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_list + return p +} + +func InitEmptyColumn_listContext(p *Column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_list +} + +func (*Column_listContext) IsColumn_listContext() {} + +func NewColumn_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_listContext { + var p = new(Column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_list + + return p +} + +func (s *Column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_listContext) AllColumn_name() []IColumn_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_nameContext); ok { + len++ + } + } + + tst := make([]IColumn_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_nameContext); ok { + tst[i] = t.(IColumn_nameContext) + i++ + } + } + + return tst +} + +func (s *Column_listContext) Column_name(i int) IColumn_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_list(s) + } +} + +func (s *Column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_list(s) + } +} + +func (s *Column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_list() (localctx IColumn_listContext) { + localctx = NewColumn_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 876, SnowflakeParserRULE_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10560) + p.Column_name() + } + p.SetState(10565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10561) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10562) + p.Column_name() + } + + p.SetState(10567) + 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 +} + +// IObject_nameContext is an interface to support dynamic dispatch. +type IObject_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IId_Context + + // GetS returns the s rule contexts. + GetS() IId_Context + + // GetO returns the o rule contexts. + GetO() IId_Context + + // SetD sets the d rule contexts. + SetD(IId_Context) + + // SetS sets the s rule contexts. + SetS(IId_Context) + + // SetO sets the o rule contexts. + SetO(IId_Context) + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsObject_nameContext differentiates from other interfaces. + IsObject_nameContext() +} + +type Object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IId_Context + s IId_Context + o IId_Context +} + +func NewEmptyObject_nameContext() *Object_nameContext { + var p = new(Object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_name + return p +} + +func InitEmptyObject_nameContext(p *Object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_name +} + +func (*Object_nameContext) IsObject_nameContext() {} + +func NewObject_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_nameContext { + var p = new(Object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_object_name + + return p +} + +func (s *Object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_nameContext) GetD() IId_Context { return s.d } + +func (s *Object_nameContext) GetS() IId_Context { return s.s } + +func (s *Object_nameContext) GetO() IId_Context { return s.o } + +func (s *Object_nameContext) SetD(v IId_Context) { s.d = v } + +func (s *Object_nameContext) SetS(v IId_Context) { s.s = v } + +func (s *Object_nameContext) SetO(v IId_Context) { s.o = v } + +func (s *Object_nameContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserDOT) +} + +func (s *Object_nameContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, i) +} + +func (s *Object_nameContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Object_nameContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterObject_name(s) + } +} + +func (s *Object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_name(s) + } +} + +func (s *Object_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_name() (localctx IObject_nameContext) { + localctx = NewObject_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 878, SnowflakeParserRULE_object_name) + p.SetState(10579) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1359, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10568) + + var _x = p.Id_() + + localctx.(*Object_nameContext).d = _x + } + { + p.SetState(10569) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10570) + + var _x = p.Id_() + + localctx.(*Object_nameContext).s = _x + } + { + p.SetState(10571) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10572) + + var _x = p.Id_() + + localctx.(*Object_nameContext).o = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10574) + + var _x = p.Id_() + + localctx.(*Object_nameContext).s = _x + } + { + p.SetState(10575) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10576) + + var _x = p.Id_() + + localctx.(*Object_nameContext).o = _x + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10578) + + var _x = p.Id_() + + localctx.(*Object_nameContext).o = _x + } + + 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 +} + +// INumContext is an interface to support dynamic dispatch. +type INumContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DECIMAL() antlr.TerminalNode + + // IsNumContext differentiates from other interfaces. + IsNumContext() +} + +type NumContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumContext() *NumContext { + var p = new(NumContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_num + return p +} + +func InitEmptyNumContext(p *NumContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_num +} + +func (*NumContext) IsNumContext() {} + +func NewNumContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumContext { + var p = new(NumContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_num + + return p +} + +func (s *NumContext) GetParser() antlr.Parser { return s.parser } + +func (s *NumContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDECIMAL, 0) +} + +func (s *NumContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NumContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NumContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterNum(s) + } +} + +func (s *NumContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitNum(s) + } +} + +func (s *NumContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitNum(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Num() (localctx INumContext) { + localctx = NewNumContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 880, SnowflakeParserRULE_num) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10581) + p.Match(SnowflakeParserDECIMAL) + 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 +} + +// IExpr_listContext is an interface to support dynamic dispatch. +type IExpr_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpr() []IExprContext + Expr(i int) IExprContext + 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 = SnowflakeParserRULE_expr_list + return p +} + +func InitEmptyExpr_listContext(p *Expr_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_expr_list + + return p +} + +func (s *Expr_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_listContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Expr_listContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Expr_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Expr_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 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.(SnowflakeParserListener); ok { + listenerT.EnterExpr_list(s) + } +} + +func (s *Expr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExpr_list(s) + } +} + +func (s *Expr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExpr_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Expr_list() (localctx IExpr_listContext) { + localctx = NewExpr_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 882, SnowflakeParserRULE_expr_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10583) + p.expr(0) + } + p.SetState(10588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10584) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10585) + p.expr(0) + } + + p.SetState(10590) + 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 +} + +// IExpr_list_sortedContext is an interface to support dynamic dispatch. +type IExpr_list_sortedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpr() []IExprContext + Expr(i int) IExprContext + AllAsc_desc() []IAsc_descContext + Asc_desc(i int) IAsc_descContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExpr_list_sortedContext differentiates from other interfaces. + IsExpr_list_sortedContext() +} + +type Expr_list_sortedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpr_list_sortedContext() *Expr_list_sortedContext { + var p = new(Expr_list_sortedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expr_list_sorted + return p +} + +func InitEmptyExpr_list_sortedContext(p *Expr_list_sortedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expr_list_sorted +} + +func (*Expr_list_sortedContext) IsExpr_list_sortedContext() {} + +func NewExpr_list_sortedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_list_sortedContext { + var p = new(Expr_list_sortedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_expr_list_sorted + + return p +} + +func (s *Expr_list_sortedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_list_sortedContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Expr_list_sortedContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Expr_list_sortedContext) AllAsc_desc() []IAsc_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAsc_descContext); ok { + len++ + } + } + + tst := make([]IAsc_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAsc_descContext); ok { + tst[i] = t.(IAsc_descContext) + i++ + } + } + + return tst +} + +func (s *Expr_list_sortedContext) Asc_desc(i int) IAsc_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAsc_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAsc_descContext) +} + +func (s *Expr_list_sortedContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Expr_list_sortedContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Expr_list_sortedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expr_list_sortedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expr_list_sortedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExpr_list_sorted(s) + } +} + +func (s *Expr_list_sortedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExpr_list_sorted(s) + } +} + +func (s *Expr_list_sortedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExpr_list_sorted(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Expr_list_sorted() (localctx IExpr_list_sortedContext) { + localctx = NewExpr_list_sortedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 884, SnowflakeParserRULE_expr_list_sorted) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10591) + p.expr(0) + } + p.SetState(10593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserASC || _la == SnowflakeParserDESC { + { + p.SetState(10592) + p.Asc_desc() + } + + } + p.SetState(10602) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10595) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10596) + p.expr(0) + } + p.SetState(10598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserASC || _la == SnowflakeParserDESC { + { + p.SetState(10597) + p.Asc_desc() + } + + } + + p.SetState(10604) + 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 +} + +// IExprContext is an interface to support dynamic dispatch. +type IExprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetOp returns the op token. + GetOp() antlr.Token + + // SetOp sets the op token. + SetOp(antlr.Token) + + // Getter signatures + Primitive_expression() IPrimitive_expressionContext + Function_call() IFunction_callContext + Case_expression() ICase_expressionContext + Iff_expr() IIff_exprContext + Full_column_name() IFull_column_nameContext + Bracket_expression() IBracket_expressionContext + AllExpr() []IExprContext + Expr(i int) IExprContext + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + NOT() antlr.TerminalNode + Arr_literal() IArr_literalContext + CAST() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AS() antlr.TerminalNode + Data_type() IData_typeContext + RR_BRACKET() antlr.TerminalNode + Json_literal() IJson_literalContext + Binary_builtin_function() IBinary_builtin_functionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Binary_or_ternary_builtin_function() IBinary_or_ternary_builtin_functionContext + Ternary_builtin_function() ITernary_builtin_functionContext + Subquery() ISubqueryContext + Try_cast_expr() ITry_cast_exprContext + Object_name() IObject_nameContext + DOT() antlr.TerminalNode + NEXTVAL() antlr.TerminalNode + Trim_expression() ITrim_expressionContext + STAR() antlr.TerminalNode + DIVIDE() antlr.TerminalNode + MODULE() antlr.TerminalNode + PIPE_PIPE() antlr.TerminalNode + AND() antlr.TerminalNode + OR() antlr.TerminalNode + COLON() antlr.TerminalNode + Comparison_operator() IComparison_operatorContext + RLIKE() antlr.TerminalNode + COLLATE() antlr.TerminalNode + String_() IStringContext + LSB() antlr.TerminalNode + RSB() antlr.TerminalNode + VALUE() antlr.TerminalNode + COLON_COLON() antlr.TerminalNode + Over_clause() IOver_clauseContext + IS() antlr.TerminalNode + Null_not_null() INull_not_nullContext + IN() antlr.TerminalNode + Expr_list() IExpr_listContext + LIKE() antlr.TerminalNode + ILIKE() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + ANY() antlr.TerminalNode + + // IsExprContext differentiates from other interfaces. + IsExprContext() +} + +type ExprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + op antlr.Token +} + +func NewEmptyExprContext() *ExprContext { + var p = new(ExprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expr + return p +} + +func InitEmptyExprContext(p *ExprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expr +} + +func (*ExprContext) IsExprContext() {} + +func NewExprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExprContext { + var p = new(ExprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_expr + + return p +} + +func (s *ExprContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExprContext) GetOp() antlr.Token { return s.op } + +func (s *ExprContext) SetOp(v antlr.Token) { s.op = v } + +func (s *ExprContext) Primitive_expression() IPrimitive_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimitive_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimitive_expressionContext) +} + +func (s *ExprContext) Function_call() IFunction_callContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_callContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_callContext) +} + +func (s *ExprContext) Case_expression() ICase_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_expressionContext) +} + +func (s *ExprContext) Iff_expr() IIff_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIff_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIff_exprContext) +} + +func (s *ExprContext) Full_column_name() IFull_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_column_nameContext) +} + +func (s *ExprContext) Bracket_expression() IBracket_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBracket_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBracket_expressionContext) +} + +func (s *ExprContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *ExprContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *ExprContext) PLUS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPLUS, 0) +} + +func (s *ExprContext) MINUS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINUS, 0) +} + +func (s *ExprContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *ExprContext) Arr_literal() IArr_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArr_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArr_literalContext) +} + +func (s *ExprContext) CAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCAST, 0) +} + +func (s *ExprContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *ExprContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *ExprContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *ExprContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *ExprContext) Json_literal() IJson_literalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_literalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_literalContext) +} + +func (s *ExprContext) Binary_builtin_function() IBinary_builtin_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBinary_builtin_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBinary_builtin_functionContext) +} + +func (s *ExprContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *ExprContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *ExprContext) Binary_or_ternary_builtin_function() IBinary_or_ternary_builtin_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBinary_or_ternary_builtin_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBinary_or_ternary_builtin_functionContext) +} + +func (s *ExprContext) Ternary_builtin_function() ITernary_builtin_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITernary_builtin_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITernary_builtin_functionContext) +} + +func (s *ExprContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *ExprContext) Try_cast_expr() ITry_cast_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITry_cast_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITry_cast_exprContext) +} + +func (s *ExprContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *ExprContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *ExprContext) NEXTVAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEXTVAL, 0) +} + +func (s *ExprContext) Trim_expression() ITrim_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrim_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrim_expressionContext) +} + +func (s *ExprContext) STAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAR, 0) +} + +func (s *ExprContext) DIVIDE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDIVIDE, 0) +} + +func (s *ExprContext) MODULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODULE, 0) +} + +func (s *ExprContext) PIPE_PIPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE_PIPE, 0) +} + +func (s *ExprContext) AND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAND, 0) +} + +func (s *ExprContext) OR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOR, 0) +} + +func (s *ExprContext) COLON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLON, 0) +} + +func (s *ExprContext) Comparison_operator() IComparison_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparison_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparison_operatorContext) +} + +func (s *ExprContext) RLIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRLIKE, 0) +} + +func (s *ExprContext) COLLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLLATE, 0) +} + +func (s *ExprContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *ExprContext) LSB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLSB, 0) +} + +func (s *ExprContext) RSB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRSB, 0) +} + +func (s *ExprContext) VALUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALUE, 0) +} + +func (s *ExprContext) COLON_COLON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLON_COLON, 0) +} + +func (s *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 *ExprContext) IS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIS, 0) +} + +func (s *ExprContext) Null_not_null() INull_not_nullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_not_nullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_not_nullContext) +} + +func (s *ExprContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *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 *ExprContext) LIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIKE, 0) +} + +func (s *ExprContext) ILIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserILIKE, 0) +} + +func (s *ExprContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserESCAPE, 0) +} + +func (s *ExprContext) ANY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserANY, 0) +} + +func (s *ExprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExpr(s) + } +} + +func (s *ExprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExpr(s) + } +} + +func (s *ExprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExpr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Expr() (localctx IExprContext) { + return p.expr(0) +} + +func (p *SnowflakeParser) expr(_p int) (localctx IExprContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewExprContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IExprContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 886 + p.EnterRecursionRule(localctx, 886, SnowflakeParserRULE_expr, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1365, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10606) + p.Primitive_expression() + } + + case 2: + { + p.SetState(10607) + p.Function_call() + } + + case 3: + { + p.SetState(10608) + p.Case_expression() + } + + case 4: + { + p.SetState(10609) + p.Iff_expr() + } + + case 5: + { + p.SetState(10610) + p.Full_column_name() + } + + case 6: + { + p.SetState(10611) + p.Bracket_expression() + } + + case 7: + { + p.SetState(10612) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ExprContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserPLUS || _la == SnowflakeParserMINUS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ExprContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10613) + p.expr(26) + } + + case 8: + { + p.SetState(10614) + + var _m = p.Match(SnowflakeParserNOT) + + localctx.(*ExprContext).op = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10615) + p.expr(25) + } + + case 9: + { + p.SetState(10616) + p.Arr_literal() + } + + case 10: + { + p.SetState(10617) + p.Match(SnowflakeParserCAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10618) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10619) + p.expr(0) + } + { + p.SetState(10620) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10621) + p.Data_type() + } + { + p.SetState(10622) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + { + p.SetState(10624) + p.Json_literal() + } + + case 12: + { + p.SetState(10625) + p.Binary_builtin_function() + } + { + p.SetState(10626) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10627) + p.expr(0) + } + { + p.SetState(10628) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10629) + p.expr(0) + } + { + p.SetState(10630) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + { + p.SetState(10632) + p.Binary_or_ternary_builtin_function() + } + { + p.SetState(10633) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10634) + p.expr(0) + } + { + p.SetState(10635) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10636) + p.expr(0) + } + p.SetState(10641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10637) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10638) + p.expr(0) + } + + p.SetState(10643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10644) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + { + p.SetState(10646) + p.Ternary_builtin_function() + } + { + p.SetState(10647) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10648) + p.expr(0) + } + { + p.SetState(10649) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10650) + p.expr(0) + } + { + p.SetState(10651) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10652) + p.expr(0) + } + { + p.SetState(10653) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + { + p.SetState(10655) + p.Subquery() + } + + case 16: + { + p.SetState(10656) + p.Try_cast_expr() + } + + case 17: + { + p.SetState(10657) + p.Object_name() + } + { + p.SetState(10658) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10659) + p.Match(SnowflakeParserNEXTVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + { + p.SetState(10661) + p.Trim_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(10749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1375, 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(10747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1374, p.GetParserRuleContext()) { + case 1: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10664) + + if !(p.Precpred(p.GetParserRuleContext(), 24)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 24)", "")) + goto errorExit + } + { + p.SetState(10665) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ExprContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1114)) & ^0x3f) == 0 && ((int64(1)<<(_la-1114))&7) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ExprContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10666) + p.expr(25) + } + + case 2: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10667) + + if !(p.Precpred(p.GetParserRuleContext(), 23)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 23)", "")) + goto errorExit + } + { + p.SetState(10668) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ExprContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1098)) & ^0x3f) == 0 && ((int64(1)<<(_la-1098))&1572865) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ExprContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10669) + p.expr(24) + } + + case 3: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10670) + + if !(p.Precpred(p.GetParserRuleContext(), 22)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 22)", "")) + goto errorExit + } + { + p.SetState(10671) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ExprContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserAND || _la == SnowflakeParserNOT || _la == SnowflakeParserOR) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ExprContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10672) + p.expr(23) + } + + case 4: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10673) + + if !(p.Precpred(p.GetParserRuleContext(), 19)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 19)", "")) + goto errorExit + } + { + p.SetState(10674) + p.Match(SnowflakeParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10675) + p.expr(20) + } + + case 5: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10676) + + if !(p.Precpred(p.GetParserRuleContext(), 6)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 6)", "")) + goto errorExit + } + { + p.SetState(10677) + p.Comparison_operator() + } + { + p.SetState(10678) + p.expr(7) + } + + case 6: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10680) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + p.SetState(10682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(10681) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10684) + p.Match(SnowflakeParserRLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10685) + p.expr(3) + } + + case 7: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10686) + + if !(p.Precpred(p.GetParserRuleContext(), 31)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 31)", "")) + goto errorExit + } + { + p.SetState(10687) + p.Match(SnowflakeParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10688) + p.String_() + } + + case 8: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10689) + + if !(p.Precpred(p.GetParserRuleContext(), 21)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 21)", "")) + goto errorExit + } + { + p.SetState(10690) + p.Match(SnowflakeParserLSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10691) + p.expr(0) + } + { + p.SetState(10692) + p.Match(SnowflakeParserRSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10694) + + if !(p.Precpred(p.GetParserRuleContext(), 18)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 18)", "")) + goto errorExit + } + { + p.SetState(10695) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10696) + p.Match(SnowflakeParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10697) + + if !(p.Precpred(p.GetParserRuleContext(), 17)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 17)", "")) + goto errorExit + } + { + p.SetState(10698) + p.Match(SnowflakeParserCOLON_COLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10699) + p.Data_type() + } + + case 11: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10700) + + if !(p.Precpred(p.GetParserRuleContext(), 16)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 16)", "")) + goto errorExit + } + { + p.SetState(10701) + p.Over_clause() + } + + case 12: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10702) + + if !(p.Precpred(p.GetParserRuleContext(), 5)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 5)", "")) + goto errorExit + } + { + p.SetState(10703) + p.Match(SnowflakeParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10704) + p.Null_not_null() + } + + case 13: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10705) + + if !(p.Precpred(p.GetParserRuleContext(), 4)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 4)", "")) + goto errorExit + } + p.SetState(10707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(10706) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10709) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10710) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1368, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10711) + p.Subquery() + } + + case 2: + { + p.SetState(10712) + p.Expr_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(10715) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10717) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + p.SetState(10719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(10718) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10721) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserILIKE || _la == SnowflakeParserLIKE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10722) + p.expr(0) + } + p.SetState(10725) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1370, p.GetParserRuleContext()) == 1 { + { + p.SetState(10723) + p.Match(SnowflakeParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10724) + p.expr(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 15: + localctx = NewExprContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_expr) + p.SetState(10727) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + p.SetState(10729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(10728) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10731) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserILIKE || _la == SnowflakeParserLIKE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10732) + p.Match(SnowflakeParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10733) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10734) + p.expr(0) + } + p.SetState(10739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10735) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10736) + p.expr(0) + } + + p.SetState(10741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10742) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10745) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1373, p.GetParserRuleContext()) == 1 { + { + p.SetState(10743) + p.Match(SnowflakeParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10744) + p.expr(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(10751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1375, 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 +} + +// IIff_exprContext is an interface to support dynamic dispatch. +type IIff_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IFF() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Search_condition() ISearch_conditionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + RR_BRACKET() antlr.TerminalNode + + // IsIff_exprContext differentiates from other interfaces. + IsIff_exprContext() +} + +type Iff_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIff_exprContext() *Iff_exprContext { + var p = new(Iff_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_iff_expr + return p +} + +func InitEmptyIff_exprContext(p *Iff_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_iff_expr +} + +func (*Iff_exprContext) IsIff_exprContext() {} + +func NewIff_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Iff_exprContext { + var p = new(Iff_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_iff_expr + + return p +} + +func (s *Iff_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Iff_exprContext) IFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIFF, 0) +} + +func (s *Iff_exprContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Iff_exprContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Iff_exprContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Iff_exprContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Iff_exprContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Iff_exprContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Iff_exprContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Iff_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Iff_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Iff_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterIff_expr(s) + } +} + +func (s *Iff_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitIff_expr(s) + } +} + +func (s *Iff_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitIff_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Iff_expr() (localctx IIff_exprContext) { + localctx = NewIff_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 888, SnowflakeParserRULE_iff_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10752) + p.Match(SnowflakeParserIFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10753) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10754) + p.search_condition(0) + } + { + p.SetState(10755) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10756) + p.expr(0) + } + { + p.SetState(10757) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10758) + p.expr(0) + } + { + p.SetState(10759) + p.Match(SnowflakeParserRR_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 +} + +// ITrim_expressionContext is an interface to support dynamic dispatch. +type ITrim_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Expr() IExprContext + RR_BRACKET() antlr.TerminalNode + TRIM() antlr.TerminalNode + LTRIM() antlr.TerminalNode + RTRIM() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllString_() []IStringContext + String_(i int) IStringContext + + // IsTrim_expressionContext differentiates from other interfaces. + IsTrim_expressionContext() +} + +type Trim_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrim_expressionContext() *Trim_expressionContext { + var p = new(Trim_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_trim_expression + return p +} + +func InitEmptyTrim_expressionContext(p *Trim_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_trim_expression +} + +func (*Trim_expressionContext) IsTrim_expressionContext() {} + +func NewTrim_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trim_expressionContext { + var p = new(Trim_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_trim_expression + + return p +} + +func (s *Trim_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trim_expressionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Trim_expressionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Trim_expressionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Trim_expressionContext) TRIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRIM, 0) +} + +func (s *Trim_expressionContext) LTRIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLTRIM, 0) +} + +func (s *Trim_expressionContext) RTRIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRTRIM, 0) +} + +func (s *Trim_expressionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Trim_expressionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Trim_expressionContext) AllString_() []IStringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStringContext); ok { + len++ + } + } + + tst := make([]IStringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStringContext); ok { + tst[i] = t.(IStringContext) + i++ + } + } + + return tst +} + +func (s *Trim_expressionContext) String_(i int) IStringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Trim_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trim_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trim_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTrim_expression(s) + } +} + +func (s *Trim_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTrim_expression(s) + } +} + +func (s *Trim_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTrim_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Trim_expression() (localctx ITrim_expressionContext) { + localctx = NewTrim_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 890, SnowflakeParserRULE_trim_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10761) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserLTRIM || _la == SnowflakeParserRTRIM || _la == SnowflakeParserTRIM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10762) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10763) + p.expr(0) + } + p.SetState(10768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10764) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10765) + p.String_() + } + + p.SetState(10770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10771) + p.Match(SnowflakeParserRR_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 +} + +// ITry_cast_exprContext is an interface to support dynamic dispatch. +type ITry_cast_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRY_CAST() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expr() IExprContext + AS() antlr.TerminalNode + Data_type() IData_typeContext + RR_BRACKET() antlr.TerminalNode + + // IsTry_cast_exprContext differentiates from other interfaces. + IsTry_cast_exprContext() +} + +type Try_cast_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTry_cast_exprContext() *Try_cast_exprContext { + var p = new(Try_cast_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_try_cast_expr + return p +} + +func InitEmptyTry_cast_exprContext(p *Try_cast_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_try_cast_expr +} + +func (*Try_cast_exprContext) IsTry_cast_exprContext() {} + +func NewTry_cast_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Try_cast_exprContext { + var p = new(Try_cast_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_try_cast_expr + + return p +} + +func (s *Try_cast_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Try_cast_exprContext) TRY_CAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRY_CAST, 0) +} + +func (s *Try_cast_exprContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Try_cast_exprContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Try_cast_exprContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Try_cast_exprContext) Data_type() IData_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_typeContext) +} + +func (s *Try_cast_exprContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Try_cast_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Try_cast_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Try_cast_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTry_cast_expr(s) + } +} + +func (s *Try_cast_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTry_cast_expr(s) + } +} + +func (s *Try_cast_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTry_cast_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Try_cast_expr() (localctx ITry_cast_exprContext) { + localctx = NewTry_cast_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 892, SnowflakeParserRULE_try_cast_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10773) + p.Match(SnowflakeParserTRY_CAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10774) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10775) + p.expr(0) + } + { + p.SetState(10776) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10777) + p.Data_type() + } + { + p.SetState(10778) + p.Match(SnowflakeParserRR_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 +} + +// IJson_literalContext is an interface to support dynamic dispatch. +type IJson_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LCB() antlr.TerminalNode + AllKv_pair() []IKv_pairContext + Kv_pair(i int) IKv_pairContext + RCB() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsJson_literalContext differentiates from other interfaces. + IsJson_literalContext() +} + +type Json_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_literalContext() *Json_literalContext { + var p = new(Json_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_json_literal + return p +} + +func InitEmptyJson_literalContext(p *Json_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_json_literal +} + +func (*Json_literalContext) IsJson_literalContext() {} + +func NewJson_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_literalContext { + var p = new(Json_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_json_literal + + return p +} + +func (s *Json_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_literalContext) LCB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLCB, 0) +} + +func (s *Json_literalContext) AllKv_pair() []IKv_pairContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKv_pairContext); ok { + len++ + } + } + + tst := make([]IKv_pairContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKv_pairContext); ok { + tst[i] = t.(IKv_pairContext) + i++ + } + } + + return tst +} + +func (s *Json_literalContext) Kv_pair(i int) IKv_pairContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKv_pairContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKv_pairContext) +} + +func (s *Json_literalContext) RCB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRCB, 0) +} + +func (s *Json_literalContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Json_literalContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Json_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterJson_literal(s) + } +} + +func (s *Json_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitJson_literal(s) + } +} + +func (s *Json_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitJson_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Json_literal() (localctx IJson_literalContext) { + localctx = NewJson_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 894, SnowflakeParserRULE_json_literal) + var _la int + + p.SetState(10793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1378, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10780) + p.Match(SnowflakeParserLCB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10781) + p.Kv_pair() + } + p.SetState(10786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10782) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10783) + p.Kv_pair() + } + + p.SetState(10788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10789) + p.Match(SnowflakeParserRCB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10791) + p.Match(SnowflakeParserLCB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10792) + p.Match(SnowflakeParserRCB) + 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 +} + +// IKv_pairContext is an interface to support dynamic dispatch. +type IKv_pairContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKey returns the key token. + GetKey() antlr.Token + + // SetKey sets the key token. + SetKey(antlr.Token) + + // Getter signatures + COLON() antlr.TerminalNode + Value() IValueContext + STRING() antlr.TerminalNode + + // IsKv_pairContext differentiates from other interfaces. + IsKv_pairContext() +} + +type Kv_pairContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + key antlr.Token +} + +func NewEmptyKv_pairContext() *Kv_pairContext { + var p = new(Kv_pairContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_kv_pair + return p +} + +func InitEmptyKv_pairContext(p *Kv_pairContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_kv_pair +} + +func (*Kv_pairContext) IsKv_pairContext() {} + +func NewKv_pairContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Kv_pairContext { + var p = new(Kv_pairContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_kv_pair + + return p +} + +func (s *Kv_pairContext) GetParser() antlr.Parser { return s.parser } + +func (s *Kv_pairContext) GetKey() antlr.Token { return s.key } + +func (s *Kv_pairContext) SetKey(v antlr.Token) { s.key = v } + +func (s *Kv_pairContext) COLON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLON, 0) +} + +func (s *Kv_pairContext) Value() IValueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValueContext) +} + +func (s *Kv_pairContext) STRING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING, 0) +} + +func (s *Kv_pairContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Kv_pairContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Kv_pairContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterKv_pair(s) + } +} + +func (s *Kv_pairContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitKv_pair(s) + } +} + +func (s *Kv_pairContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitKv_pair(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Kv_pair() (localctx IKv_pairContext) { + localctx = NewKv_pairContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 896, SnowflakeParserRULE_kv_pair) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10795) + + var _m = p.Match(SnowflakeParserSTRING) + + localctx.(*Kv_pairContext).key = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10796) + p.Match(SnowflakeParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10797) + p.Value() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValueContext is an interface to support dynamic dispatch. +type IValueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expr() IExprContext + + // IsValueContext differentiates from other interfaces. + IsValueContext() +} + +type ValueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValueContext() *ValueContext { + var p = new(ValueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_value + return p +} + +func InitEmptyValueContext(p *ValueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_value +} + +func (*ValueContext) IsValueContext() {} + +func NewValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueContext { + var p = new(ValueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_value + + return p +} + +func (s *ValueContext) GetParser() antlr.Parser { return s.parser } + +func (s *ValueContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *ValueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ValueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterValue(s) + } +} + +func (s *ValueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitValue(s) + } +} + +func (s *ValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitValue(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Value() (localctx IValueContext) { + localctx = NewValueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 898, SnowflakeParserRULE_value) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10799) + p.expr(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IArr_literalContext is an interface to support dynamic dispatch. +type IArr_literalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LSB() antlr.TerminalNode + AllValue() []IValueContext + Value(i int) IValueContext + RSB() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsArr_literalContext differentiates from other interfaces. + IsArr_literalContext() +} + +type Arr_literalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArr_literalContext() *Arr_literalContext { + var p = new(Arr_literalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arr_literal + return p +} + +func InitEmptyArr_literalContext(p *Arr_literalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_arr_literal +} + +func (*Arr_literalContext) IsArr_literalContext() {} + +func NewArr_literalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Arr_literalContext { + var p = new(Arr_literalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_arr_literal + + return p +} + +func (s *Arr_literalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Arr_literalContext) LSB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLSB, 0) +} + +func (s *Arr_literalContext) AllValue() []IValueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IValueContext); ok { + len++ + } + } + + tst := make([]IValueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IValueContext); ok { + tst[i] = t.(IValueContext) + i++ + } + } + + return tst +} + +func (s *Arr_literalContext) Value(i int) IValueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IValueContext) +} + +func (s *Arr_literalContext) RSB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRSB, 0) +} + +func (s *Arr_literalContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Arr_literalContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Arr_literalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Arr_literalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Arr_literalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterArr_literal(s) + } +} + +func (s *Arr_literalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitArr_literal(s) + } +} + +func (s *Arr_literalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitArr_literal(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Arr_literal() (localctx IArr_literalContext) { + localctx = NewArr_literalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 900, SnowflakeParserRULE_arr_literal) + var _la int + + p.SetState(10814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1380, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10801) + p.Match(SnowflakeParserLSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10802) + p.Value() + } + p.SetState(10807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(10803) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10804) + p.Value() + } + + p.SetState(10809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10810) + p.Match(SnowflakeParserRSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10812) + p.Match(SnowflakeParserLSB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10813) + p.Match(SnowflakeParserRSB) + 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 +} + +// IData_typeContext is an interface to support dynamic dispatch. +type IData_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INT() antlr.TerminalNode + INTEGER() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + TINYINT() antlr.TerminalNode + BYTEINT() antlr.TerminalNode + BIGINT() antlr.TerminalNode + NUMBER() antlr.TerminalNode + NUMERIC() antlr.TerminalNode + DECIMAL_() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + AllNum() []INumContext + Num(i int) INumContext + RR_BRACKET() antlr.TerminalNode + COMMA() antlr.TerminalNode + FLOAT_() antlr.TerminalNode + FLOAT4() antlr.TerminalNode + FLOAT8() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + PRECISION() antlr.TerminalNode + REAL_() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + DATE() antlr.TerminalNode + DATETIME() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TIMESTAMP_LTZ() antlr.TerminalNode + TIMESTAMP_NTZ() antlr.TerminalNode + TIMESTAMP_TZ() antlr.TerminalNode + STRING_() antlr.TerminalNode + CHAR() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + TEXT() antlr.TerminalNode + BINARY() antlr.TerminalNode + VARBINARY() antlr.TerminalNode + VARIANT() antlr.TerminalNode + OBJECT() antlr.TerminalNode + ARRAY() antlr.TerminalNode + GEOGRAPHY() antlr.TerminalNode + GEOMETRY() antlr.TerminalNode + + // IsData_typeContext differentiates from other interfaces. + IsData_typeContext() +} + +type Data_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyData_typeContext() *Data_typeContext { + var p = new(Data_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_data_type + return p +} + +func InitEmptyData_typeContext(p *Data_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_data_type +} + +func (*Data_typeContext) IsData_typeContext() {} + +func NewData_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Data_typeContext { + var p = new(Data_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_data_type + + return p +} + +func (s *Data_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Data_typeContext) INT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINT, 0) +} + +func (s *Data_typeContext) INTEGER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGER, 0) +} + +func (s *Data_typeContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSMALLINT, 0) +} + +func (s *Data_typeContext) TINYINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTINYINT, 0) +} + +func (s *Data_typeContext) BYTEINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBYTEINT, 0) +} + +func (s *Data_typeContext) BIGINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBIGINT, 0) +} + +func (s *Data_typeContext) NUMBER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNUMBER, 0) +} + +func (s *Data_typeContext) NUMERIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNUMERIC, 0) +} + +func (s *Data_typeContext) DECIMAL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDECIMAL_, 0) +} + +func (s *Data_typeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Data_typeContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Data_typeContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Data_typeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Data_typeContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Data_typeContext) FLOAT_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFLOAT_, 0) +} + +func (s *Data_typeContext) FLOAT4() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFLOAT4, 0) +} + +func (s *Data_typeContext) FLOAT8() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFLOAT8, 0) +} + +func (s *Data_typeContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOUBLE, 0) +} + +func (s *Data_typeContext) PRECISION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRECISION, 0) +} + +func (s *Data_typeContext) REAL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAL_, 0) +} + +func (s *Data_typeContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBOOLEAN, 0) +} + +func (s *Data_typeContext) DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE, 0) +} + +func (s *Data_typeContext) DATETIME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATETIME, 0) +} + +func (s *Data_typeContext) TIME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME, 0) +} + +func (s *Data_typeContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP, 0) +} + +func (s *Data_typeContext) TIMESTAMP_LTZ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_LTZ, 0) +} + +func (s *Data_typeContext) TIMESTAMP_NTZ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_NTZ, 0) +} + +func (s *Data_typeContext) TIMESTAMP_TZ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_TZ, 0) +} + +func (s *Data_typeContext) STRING_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING_, 0) +} + +func (s *Data_typeContext) CHAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHAR, 0) +} + +func (s *Data_typeContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHARACTER, 0) +} + +func (s *Data_typeContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARCHAR, 0) +} + +func (s *Data_typeContext) TEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEXT, 0) +} + +func (s *Data_typeContext) BINARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY, 0) +} + +func (s *Data_typeContext) VARBINARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARBINARY, 0) +} + +func (s *Data_typeContext) VARIANT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARIANT, 0) +} + +func (s *Data_typeContext) OBJECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT, 0) +} + +func (s *Data_typeContext) ARRAY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARRAY, 0) +} + +func (s *Data_typeContext) GEOGRAPHY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEOGRAPHY, 0) +} + +func (s *Data_typeContext) GEOMETRY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEOMETRY, 0) +} + +func (s *Data_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Data_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Data_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterData_type(s) + } +} + +func (s *Data_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitData_type(s) + } +} + +func (s *Data_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitData_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Data_type() (localctx IData_typeContext) { + localctx = NewData_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 902, SnowflakeParserRULE_data_type) + var _la int + + p.SetState(10903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserINT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10816) + p.Match(SnowflakeParserINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserINTEGER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10817) + p.Match(SnowflakeParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserSMALLINT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10818) + p.Match(SnowflakeParserSMALLINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserTINYINT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10819) + p.Match(SnowflakeParserTINYINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserBYTEINT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10820) + p.Match(SnowflakeParserBYTEINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserBIGINT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10821) + p.Match(SnowflakeParserBIGINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserNUMBER, SnowflakeParserDECIMAL_, SnowflakeParserNUMERIC: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10822) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserNUMBER || _la == SnowflakeParserDECIMAL_ || _la == SnowflakeParserNUMERIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10831) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1382, p.GetParserRuleContext()) == 1 { + { + p.SetState(10823) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10824) + p.Num() + } + p.SetState(10827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMA { + { + p.SetState(10825) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10826) + p.Num() + } + + } + { + p.SetState(10829) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserFLOAT_: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10833) + p.Match(SnowflakeParserFLOAT_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFLOAT4: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(10834) + p.Match(SnowflakeParserFLOAT4) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFLOAT8: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(10835) + p.Match(SnowflakeParserFLOAT8) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDOUBLE: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(10836) + p.Match(SnowflakeParserDOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10838) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1383, p.GetParserRuleContext()) == 1 { + { + p.SetState(10837) + p.Match(SnowflakeParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserREAL_: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(10840) + p.Match(SnowflakeParserREAL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserBOOLEAN: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(10841) + p.Match(SnowflakeParserBOOLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATE: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(10842) + p.Match(SnowflakeParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserDATETIME: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(10843) + p.Match(SnowflakeParserDATETIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10848) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1384, p.GetParserRuleContext()) == 1 { + { + p.SetState(10844) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10845) + p.Num() + } + { + p.SetState(10846) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserTIME: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(10850) + p.Match(SnowflakeParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10855) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1385, p.GetParserRuleContext()) == 1 { + { + p.SetState(10851) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10852) + p.Num() + } + { + p.SetState(10853) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserTIMESTAMP: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(10857) + p.Match(SnowflakeParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10862) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1386, p.GetParserRuleContext()) == 1 { + { + p.SetState(10858) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10859) + p.Num() + } + { + p.SetState(10860) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserTIMESTAMP_LTZ: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(10864) + p.Match(SnowflakeParserTIMESTAMP_LTZ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10869) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1387, p.GetParserRuleContext()) == 1 { + { + p.SetState(10865) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10866) + p.Num() + } + { + p.SetState(10867) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserTIMESTAMP_NTZ: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(10871) + p.Match(SnowflakeParserTIMESTAMP_NTZ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10876) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1388, p.GetParserRuleContext()) == 1 { + { + p.SetState(10872) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10873) + p.Num() + } + { + p.SetState(10874) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserTIMESTAMP_TZ: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(10878) + p.Match(SnowflakeParserTIMESTAMP_TZ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10883) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1389, p.GetParserRuleContext()) == 1 { + { + p.SetState(10879) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10880) + p.Num() + } + { + p.SetState(10881) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserSTRING_: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(10885) + p.Match(SnowflakeParserSTRING_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserCHAR: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(10886) + p.Match(SnowflakeParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserCHARACTER: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(10887) + p.Match(SnowflakeParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserVARCHAR: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(10888) + p.Match(SnowflakeParserVARCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10893) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1390, p.GetParserRuleContext()) == 1 { + { + p.SetState(10889) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10890) + p.Num() + } + { + p.SetState(10891) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserTEXT: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(10895) + p.Match(SnowflakeParserTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserBINARY: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(10896) + p.Match(SnowflakeParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserVARBINARY: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(10897) + p.Match(SnowflakeParserVARBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserVARIANT: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(10898) + p.Match(SnowflakeParserVARIANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserOBJECT: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(10899) + p.Match(SnowflakeParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserARRAY: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(10900) + p.Match(SnowflakeParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserGEOGRAPHY: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(10901) + p.Match(SnowflakeParserGEOGRAPHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserGEOMETRY: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(10902) + p.Match(SnowflakeParserGEOMETRY) + 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 +} + +// IPrimitive_expressionContext is an interface to support dynamic dispatch. +type IPrimitive_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + NULL_() antlr.TerminalNode + Id_() IId_Context + Literal() ILiteralContext + + // IsPrimitive_expressionContext differentiates from other interfaces. + IsPrimitive_expressionContext() +} + +type Primitive_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimitive_expressionContext() *Primitive_expressionContext { + var p = new(Primitive_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_primitive_expression + return p +} + +func InitEmptyPrimitive_expressionContext(p *Primitive_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_primitive_expression +} + +func (*Primitive_expressionContext) IsPrimitive_expressionContext() {} + +func NewPrimitive_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primitive_expressionContext { + var p = new(Primitive_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_primitive_expression + + return p +} + +func (s *Primitive_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primitive_expressionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT, 0) +} + +func (s *Primitive_expressionContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Primitive_expressionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Primitive_expressionContext) Literal() ILiteralContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Primitive_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primitive_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primitive_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPrimitive_expression(s) + } +} + +func (s *Primitive_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPrimitive_expression(s) + } +} + +func (s *Primitive_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPrimitive_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Primitive_expression() (localctx IPrimitive_expressionContext) { + localctx = NewPrimitive_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 904, SnowflakeParserRULE_primitive_expression) + p.SetState(10909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1392, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10905) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10906) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10907) + p.Id_() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10908) + p.Literal() + } + + 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 +} + +// IOrder_by_exprContext is an interface to support dynamic dispatch. +type IOrder_by_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + Expr_list_sorted() IExpr_list_sortedContext + + // IsOrder_by_exprContext differentiates from other interfaces. + IsOrder_by_exprContext() +} + +type Order_by_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_by_exprContext() *Order_by_exprContext { + var p = new(Order_by_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_order_by_expr + return p +} + +func InitEmptyOrder_by_exprContext(p *Order_by_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_order_by_expr +} + +func (*Order_by_exprContext) IsOrder_by_exprContext() {} + +func NewOrder_by_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_exprContext { + var p = new(Order_by_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_order_by_expr + + return p +} + +func (s *Order_by_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_exprContext) ORDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORDER, 0) +} + +func (s *Order_by_exprContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Order_by_exprContext) Expr_list_sorted() IExpr_list_sortedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_list_sortedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_list_sortedContext) +} + +func (s *Order_by_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterOrder_by_expr(s) + } +} + +func (s *Order_by_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitOrder_by_expr(s) + } +} + +func (s *Order_by_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitOrder_by_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Order_by_expr() (localctx IOrder_by_exprContext) { + localctx = NewOrder_by_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 906, SnowflakeParserRULE_order_by_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10911) + p.Match(SnowflakeParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10912) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10913) + p.Expr_list_sorted() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAsc_descContext is an interface to support dynamic dispatch. +type IAsc_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsAsc_descContext differentiates from other interfaces. + IsAsc_descContext() +} + +type Asc_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAsc_descContext() *Asc_descContext { + var p = new(Asc_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_asc_desc + return p +} + +func InitEmptyAsc_descContext(p *Asc_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_asc_desc +} + +func (*Asc_descContext) IsAsc_descContext() {} + +func NewAsc_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Asc_descContext { + var p = new(Asc_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_asc_desc + + return p +} + +func (s *Asc_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Asc_descContext) ASC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASC, 0) +} + +func (s *Asc_descContext) DESC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDESC, 0) +} + +func (s *Asc_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Asc_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Asc_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAsc_desc(s) + } +} + +func (s *Asc_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAsc_desc(s) + } +} + +func (s *Asc_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAsc_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Asc_desc() (localctx IAsc_descContext) { + localctx = NewAsc_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 908, SnowflakeParserRULE_asc_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10915) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserASC || _la == SnowflakeParserDESC) { + 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 +} + +// 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 + LR_BRACKET() antlr.TerminalNode + Partition_by() IPartition_byContext + RR_BRACKET() antlr.TerminalNode + Order_by_expr() IOrder_by_exprContext + + // 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 = SnowflakeParserRULE_over_clause + return p +} + +func InitEmptyOver_clauseContext(p *Over_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_over_clause + + return p +} + +func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Over_clauseContext) OVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOVER, 0) +} + +func (s *Over_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Over_clauseContext) Partition_by() IPartition_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_byContext) +} + +func (s *Over_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Over_clauseContext) Order_by_expr() IOrder_by_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_exprContext) +} + +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.(SnowflakeParserListener); ok { + listenerT.EnterOver_clause(s) + } +} + +func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitOver_clause(s) + } +} + +func (s *Over_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitOver_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Over_clause() (localctx IOver_clauseContext) { + localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 910, SnowflakeParserRULE_over_clause) + var _la int + + p.SetState(10930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1394, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10917) + p.Match(SnowflakeParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10918) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10919) + p.Partition_by() + } + p.SetState(10921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserORDER { + { + p.SetState(10920) + p.Order_by_expr() + } + + } + { + p.SetState(10923) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10925) + p.Match(SnowflakeParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10926) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10927) + p.Order_by_expr() + } + { + p.SetState(10928) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// IFunction_callContext is an interface to support dynamic dispatch. +type IFunction_callContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTo_date returns the to_date token. + GetTo_date() antlr.Token + + // GetLength returns the length token. + GetLength() antlr.Token + + // SetTo_date sets the to_date token. + SetTo_date(antlr.Token) + + // SetLength sets the length token. + SetLength(antlr.Token) + + // Getter signatures + Ranking_windowed_function() IRanking_windowed_functionContext + Aggregate_function() IAggregate_functionContext + Object_name() IObject_nameContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Expr_list() IExpr_listContext + List_operator() IList_operatorContext + Expr() IExprContext + TO_DATE() antlr.TerminalNode + DATE() antlr.TerminalNode + LENGTH() antlr.TerminalNode + LEN() antlr.TerminalNode + TO_BOOLEAN() antlr.TerminalNode + + // IsFunction_callContext differentiates from other interfaces. + IsFunction_callContext() +} + +type Function_callContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + to_date antlr.Token + length antlr.Token +} + +func NewEmptyFunction_callContext() *Function_callContext { + var p = new(Function_callContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_function_call + return p +} + +func InitEmptyFunction_callContext(p *Function_callContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_function_call +} + +func (*Function_callContext) IsFunction_callContext() {} + +func NewFunction_callContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_callContext { + var p = new(Function_callContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_function_call + + return p +} + +func (s *Function_callContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_callContext) GetTo_date() antlr.Token { return s.to_date } + +func (s *Function_callContext) GetLength() antlr.Token { return s.length } + +func (s *Function_callContext) SetTo_date(v antlr.Token) { s.to_date = v } + +func (s *Function_callContext) SetLength(v antlr.Token) { s.length = v } + +func (s *Function_callContext) Ranking_windowed_function() IRanking_windowed_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRanking_windowed_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRanking_windowed_functionContext) +} + +func (s *Function_callContext) Aggregate_function() IAggregate_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_functionContext) +} + +func (s *Function_callContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Function_callContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Function_callContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Function_callContext) 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 *Function_callContext) List_operator() IList_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_operatorContext) +} + +func (s *Function_callContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Function_callContext) TO_DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO_DATE, 0) +} + +func (s *Function_callContext) DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE, 0) +} + +func (s *Function_callContext) LENGTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLENGTH, 0) +} + +func (s *Function_callContext) LEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLEN, 0) +} + +func (s *Function_callContext) TO_BOOLEAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO_BOOLEAN, 0) +} + +func (s *Function_callContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_callContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_callContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFunction_call(s) + } +} + +func (s *Function_callContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFunction_call(s) + } +} + +func (s *Function_callContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFunction_call(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Function_call() (localctx IFunction_callContext) { + localctx = NewFunction_callContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 912, SnowflakeParserRULE_function_call) + var _la int + + p.SetState(10961) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1396, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10932) + p.Ranking_windowed_function() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10933) + p.Aggregate_function() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10934) + p.Object_name() + } + { + p.SetState(10935) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-211110795935745) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184908959745) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3463268149149828613) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-1099515850833) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-35184372088833) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173377025) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950977) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-36283900493953) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-216181718867017753) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&2165536527268970481) != 0) || ((int64((_la-1099)) & ^0x3f) == 0 && ((int64(1)<<(_la-1099))&787113) != 0) { + { + p.SetState(10936) + p.Expr_list() + } + + } + { + p.SetState(10939) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10941) + p.List_operator() + } + { + p.SetState(10942) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10943) + p.Expr_list() + } + { + p.SetState(10944) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10946) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Function_callContext).to_date = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserTO_DATE || _la == SnowflakeParserDATE) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Function_callContext).to_date = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10947) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10948) + p.expr(0) + } + { + p.SetState(10949) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10951) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Function_callContext).length = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserLEN || _la == SnowflakeParserLENGTH) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Function_callContext).length = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10952) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10953) + p.expr(0) + } + { + p.SetState(10954) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10956) + p.Match(SnowflakeParserTO_BOOLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10957) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10958) + p.expr(0) + } + { + p.SetState(10959) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// IRanking_windowed_functionContext is an interface to support dynamic dispatch. +type IRanking_windowed_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Over_clause() IOver_clauseContext + RANK() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + NTILE() antlr.TerminalNode + Expr() IExprContext + + // IsRanking_windowed_functionContext differentiates from other interfaces. + IsRanking_windowed_functionContext() +} + +type Ranking_windowed_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRanking_windowed_functionContext() *Ranking_windowed_functionContext { + var p = new(Ranking_windowed_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ranking_windowed_function + return p +} + +func InitEmptyRanking_windowed_functionContext(p *Ranking_windowed_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_ranking_windowed_function +} + +func (*Ranking_windowed_functionContext) IsRanking_windowed_functionContext() {} + +func NewRanking_windowed_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ranking_windowed_functionContext { + var p = new(Ranking_windowed_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_ranking_windowed_function + + return p +} + +func (s *Ranking_windowed_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ranking_windowed_functionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Ranking_windowed_functionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Ranking_windowed_functionContext) 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 *Ranking_windowed_functionContext) RANK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRANK, 0) +} + +func (s *Ranking_windowed_functionContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDENSE_RANK, 0) +} + +func (s *Ranking_windowed_functionContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW_NUMBER, 0) +} + +func (s *Ranking_windowed_functionContext) NTILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNTILE, 0) +} + +func (s *Ranking_windowed_functionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Ranking_windowed_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ranking_windowed_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ranking_windowed_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRanking_windowed_function(s) + } +} + +func (s *Ranking_windowed_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRanking_windowed_function(s) + } +} + +func (s *Ranking_windowed_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRanking_windowed_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Ranking_windowed_function() (localctx IRanking_windowed_functionContext) { + localctx = NewRanking_windowed_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 914, SnowflakeParserRULE_ranking_windowed_function) + var _la int + + p.SetState(10973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDENSE_RANK, SnowflakeParserRANK, SnowflakeParserROW_NUMBER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10963) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserDENSE_RANK || _la == SnowflakeParserRANK || _la == SnowflakeParserROW_NUMBER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10964) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10965) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10966) + p.Over_clause() + } + + case SnowflakeParserNTILE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10967) + p.Match(SnowflakeParserNTILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10968) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10969) + p.expr(0) + } + { + p.SetState(10970) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10971) + p.Over_clause() + } + + 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 +} + +// IAggregate_functionContext is an interface to support dynamic dispatch. +type IAggregate_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Expr_list() IExpr_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + DISTINCT() antlr.TerminalNode + STAR() antlr.TerminalNode + LISTAGG() antlr.TerminalNode + Expr() IExprContext + COMMA() antlr.TerminalNode + String_() IStringContext + WITHIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + + // IsAggregate_functionContext differentiates from other interfaces. + IsAggregate_functionContext() +} + +type Aggregate_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggregate_functionContext() *Aggregate_functionContext { + var p = new(Aggregate_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aggregate_function + return p +} + +func InitEmptyAggregate_functionContext(p *Aggregate_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_aggregate_function +} + +func (*Aggregate_functionContext) IsAggregate_functionContext() {} + +func NewAggregate_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_functionContext { + var p = new(Aggregate_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_aggregate_function + + return p +} + +func (s *Aggregate_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggregate_functionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Aggregate_functionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Aggregate_functionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Aggregate_functionContext) 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 *Aggregate_functionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Aggregate_functionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Aggregate_functionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISTINCT, 0) +} + +func (s *Aggregate_functionContext) STAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAR, 0) +} + +func (s *Aggregate_functionContext) LISTAGG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLISTAGG, 0) +} + +func (s *Aggregate_functionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Aggregate_functionContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +func (s *Aggregate_functionContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Aggregate_functionContext) WITHIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITHIN, 0) +} + +func (s *Aggregate_functionContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Aggregate_functionContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Aggregate_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggregate_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggregate_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAggregate_function(s) + } +} + +func (s *Aggregate_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAggregate_function(s) + } +} + +func (s *Aggregate_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAggregate_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Aggregate_function() (localctx IAggregate_functionContext) { + localctx = NewAggregate_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 916, SnowflakeParserRULE_aggregate_function) + var _la int + + p.SetState(11007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1402, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10975) + p.Id_() + } + { + p.SetState(10976) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10978) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDISTINCT { + { + p.SetState(10977) + p.Match(SnowflakeParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10980) + p.Expr_list() + } + { + p.SetState(10981) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10983) + p.Id_() + } + { + p.SetState(10984) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10985) + p.Match(SnowflakeParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10986) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10988) + p.Match(SnowflakeParserLISTAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10989) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDISTINCT { + { + p.SetState(10990) + p.Match(SnowflakeParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10993) + p.expr(0) + } + p.SetState(10996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserCOMMA { + { + p.SetState(10994) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10995) + p.String_() + } + + } + { + p.SetState(10998) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11005) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1401, p.GetParserRuleContext()) == 1 { + { + p.SetState(10999) + p.Match(SnowflakeParserWITHIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11000) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11001) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11002) + p.Order_by_clause() + } + { + p.SetState(11003) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// ILiteralContext is an interface to support dynamic dispatch. +type ILiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STRING() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + Sign() ISignContext + REAL() antlr.TerminalNode + FLOAT() antlr.TerminalNode + True_false() ITrue_falseContext + NULL_() antlr.TerminalNode + AT_Q() antlr.TerminalNode + + // IsLiteralContext differentiates from other interfaces. + IsLiteralContext() +} + +type LiteralContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLiteralContext() *LiteralContext { + var p = new(LiteralContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_literal + return p +} + +func InitEmptyLiteralContext(p *LiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_literal +} + +func (*LiteralContext) IsLiteralContext() {} + +func NewLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LiteralContext { + var p = new(LiteralContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_literal + + return p +} + +func (s *LiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *LiteralContext) STRING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING, 0) +} + +func (s *LiteralContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDECIMAL, 0) +} + +func (s *LiteralContext) Sign() ISignContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISignContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISignContext) +} + +func (s *LiteralContext) REAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAL, 0) +} + +func (s *LiteralContext) FLOAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFLOAT, 0) +} + +func (s *LiteralContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *LiteralContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *LiteralContext) AT_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAT_Q, 0) +} + +func (s *LiteralContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LiteralContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterLiteral(s) + } +} + +func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitLiteral(s) + } +} + +func (s *LiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Literal() (localctx ILiteralContext) { + localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 918, SnowflakeParserRULE_literal) + var _la int + + p.SetState(11021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1405, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11009) + p.Match(SnowflakeParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(11011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPLUS || _la == SnowflakeParserMINUS { + { + p.SetState(11010) + p.Sign() + } + + } + { + p.SetState(11013) + p.Match(SnowflakeParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(11015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPLUS || _la == SnowflakeParserMINUS { + { + p.SetState(11014) + p.Sign() + } + + } + { + p.SetState(11017) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserFLOAT || _la == SnowflakeParserREAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11018) + p.True_false() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11019) + p.Match(SnowflakeParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11020) + p.Match(SnowflakeParserAT_Q) + 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 +} + +// ISignContext is an interface to support dynamic dispatch. +type ISignContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PLUS() antlr.TerminalNode + MINUS() antlr.TerminalNode + + // IsSignContext differentiates from other interfaces. + IsSignContext() +} + +type SignContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySignContext() *SignContext { + var p = new(SignContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sign + return p +} + +func InitEmptySignContext(p *SignContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sign +} + +func (*SignContext) IsSignContext() {} + +func NewSignContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SignContext { + var p = new(SignContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_sign + + return p +} + +func (s *SignContext) GetParser() antlr.Parser { return s.parser } + +func (s *SignContext) PLUS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPLUS, 0) +} + +func (s *SignContext) MINUS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINUS, 0) +} + +func (s *SignContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SignContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SignContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSign(s) + } +} + +func (s *SignContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSign(s) + } +} + +func (s *SignContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSign(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Sign() (localctx ISignContext) { + localctx = NewSignContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 920, SnowflakeParserRULE_sign) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11023) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserPLUS || _la == SnowflakeParserMINUS) { + 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 +} + +// IFull_column_nameContext is an interface to support dynamic dispatch. +type IFull_column_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDb_name returns the db_name rule contexts. + GetDb_name() IId_Context + + // GetSchema returns the schema rule contexts. + GetSchema() IId_Context + + // GetTab_name returns the tab_name rule contexts. + GetTab_name() IId_Context + + // GetCol_name returns the col_name rule contexts. + GetCol_name() IId_Context + + // SetDb_name sets the db_name rule contexts. + SetDb_name(IId_Context) + + // SetSchema sets the schema rule contexts. + SetSchema(IId_Context) + + // SetTab_name sets the tab_name rule contexts. + SetTab_name(IId_Context) + + // SetCol_name sets the col_name rule contexts. + SetCol_name(IId_Context) + + // Getter signatures + AllDOT() []antlr.TerminalNode + DOT(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + + // IsFull_column_nameContext differentiates from other interfaces. + IsFull_column_nameContext() +} + +type Full_column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + db_name IId_Context + schema IId_Context + tab_name IId_Context + col_name IId_Context +} + +func NewEmptyFull_column_nameContext() *Full_column_nameContext { + var p = new(Full_column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_full_column_name + return p +} + +func InitEmptyFull_column_nameContext(p *Full_column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_full_column_name +} + +func (*Full_column_nameContext) IsFull_column_nameContext() {} + +func NewFull_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_column_nameContext { + var p = new(Full_column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_full_column_name + + return p +} + +func (s *Full_column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_column_nameContext) GetDb_name() IId_Context { return s.db_name } + +func (s *Full_column_nameContext) GetSchema() IId_Context { return s.schema } + +func (s *Full_column_nameContext) GetTab_name() IId_Context { return s.tab_name } + +func (s *Full_column_nameContext) GetCol_name() IId_Context { return s.col_name } + +func (s *Full_column_nameContext) SetDb_name(v IId_Context) { s.db_name = v } + +func (s *Full_column_nameContext) SetSchema(v IId_Context) { s.schema = v } + +func (s *Full_column_nameContext) SetTab_name(v IId_Context) { s.tab_name = v } + +func (s *Full_column_nameContext) SetCol_name(v IId_Context) { s.col_name = v } + +func (s *Full_column_nameContext) AllDOT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserDOT) +} + +func (s *Full_column_nameContext) DOT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, i) +} + +func (s *Full_column_nameContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Full_column_nameContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Full_column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFull_column_name(s) + } +} + +func (s *Full_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFull_column_name(s) + } +} + +func (s *Full_column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFull_column_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Full_column_name() (localctx IFull_column_nameContext) { + localctx = NewFull_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 922, SnowflakeParserRULE_full_column_name) + var _la int + + p.SetState(11053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1412, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(11026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(11025) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).db_name = _x + } + + } + { + p.SetState(11028) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(11029) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).schema = _x + } + + } + { + p.SetState(11032) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11034) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(11033) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).tab_name = _x + } + + } + { + p.SetState(11036) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11037) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).col_name = _x + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(11039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(11038) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).schema = _x + } + + } + { + p.SetState(11041) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(11042) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).tab_name = _x + } + + } + { + p.SetState(11045) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11046) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).col_name = _x + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(11048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(11047) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).tab_name = _x + } + + } + { + p.SetState(11050) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11051) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).col_name = _x + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11052) + + var _x = p.Id_() + + localctx.(*Full_column_nameContext).col_name = _x + } + + 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 +} + +// IBracket_expressionContext is an interface to support dynamic dispatch. +type IBracket_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Expr() IExprContext + RR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + + // IsBracket_expressionContext differentiates from other interfaces. + IsBracket_expressionContext() +} + +type Bracket_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBracket_expressionContext() *Bracket_expressionContext { + var p = new(Bracket_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_bracket_expression + return p +} + +func InitEmptyBracket_expressionContext(p *Bracket_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_bracket_expression +} + +func (*Bracket_expressionContext) IsBracket_expressionContext() {} + +func NewBracket_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bracket_expressionContext { + var p = new(Bracket_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_bracket_expression + + return p +} + +func (s *Bracket_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bracket_expressionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Bracket_expressionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Bracket_expressionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Bracket_expressionContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Bracket_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bracket_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bracket_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterBracket_expression(s) + } +} + +func (s *Bracket_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitBracket_expression(s) + } +} + +func (s *Bracket_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitBracket_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Bracket_expression() (localctx IBracket_expressionContext) { + localctx = NewBracket_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 924, SnowflakeParserRULE_bracket_expression) + p.SetState(11063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1413, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11055) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11056) + p.expr(0) + } + { + p.SetState(11057) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11059) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11060) + p.Subquery() + } + { + p.SetState(11061) + p.Match(SnowflakeParserRR_BRACKET) + 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_expressionContext is an interface to support dynamic dispatch. +type ICase_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CASE() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + END() antlr.TerminalNode + AllSwitch_section() []ISwitch_sectionContext + Switch_section(i int) ISwitch_sectionContext + ELSE() antlr.TerminalNode + AllSwitch_search_condition_section() []ISwitch_search_condition_sectionContext + Switch_search_condition_section(i int) ISwitch_search_condition_sectionContext + + // IsCase_expressionContext differentiates from other interfaces. + IsCase_expressionContext() +} + +type Case_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_expressionContext() *Case_expressionContext { + var p = new(Case_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_case_expression + return p +} + +func InitEmptyCase_expressionContext(p *Case_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_case_expression +} + +func (*Case_expressionContext) IsCase_expressionContext() {} + +func NewCase_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_expressionContext { + var p = new(Case_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_case_expression + + return p +} + +func (s *Case_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_expressionContext) CASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCASE, 0) +} + +func (s *Case_expressionContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Case_expressionContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Case_expressionContext) END() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEND, 0) +} + +func (s *Case_expressionContext) AllSwitch_section() []ISwitch_sectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISwitch_sectionContext); ok { + len++ + } + } + + tst := make([]ISwitch_sectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISwitch_sectionContext); ok { + tst[i] = t.(ISwitch_sectionContext) + i++ + } + } + + return tst +} + +func (s *Case_expressionContext) Switch_section(i int) ISwitch_sectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISwitch_sectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISwitch_sectionContext) +} + +func (s *Case_expressionContext) ELSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserELSE, 0) +} + +func (s *Case_expressionContext) AllSwitch_search_condition_section() []ISwitch_search_condition_sectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISwitch_search_condition_sectionContext); ok { + len++ + } + } + + tst := make([]ISwitch_search_condition_sectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISwitch_search_condition_sectionContext); ok { + tst[i] = t.(ISwitch_search_condition_sectionContext) + i++ + } + } + + return tst +} + +func (s *Case_expressionContext) Switch_search_condition_section(i int) ISwitch_search_condition_sectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISwitch_search_condition_sectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISwitch_search_condition_sectionContext) +} + +func (s *Case_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCase_expression(s) + } +} + +func (s *Case_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCase_expression(s) + } +} + +func (s *Case_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCase_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Case_expression() (localctx ICase_expressionContext) { + localctx = NewCase_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 926, SnowflakeParserRULE_case_expression) + var _la int + + p.SetState(11090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1418, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11065) + p.Match(SnowflakeParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11066) + p.expr(0) + } + p.SetState(11068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserWHEN { + { + p.SetState(11067) + p.Switch_section() + } + + p.SetState(11070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(11074) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserELSE { + { + p.SetState(11072) + p.Match(SnowflakeParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11073) + p.expr(0) + } + + } + { + p.SetState(11076) + p.Match(SnowflakeParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11078) + p.Match(SnowflakeParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11080) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == SnowflakeParserWHEN { + { + p.SetState(11079) + p.Switch_search_condition_section() + } + + p.SetState(11082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(11086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserELSE { + { + p.SetState(11084) + p.Match(SnowflakeParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11085) + p.expr(0) + } + + } + { + p.SetState(11088) + p.Match(SnowflakeParserEND) + 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 +} + +// ISwitch_search_condition_sectionContext is an interface to support dynamic dispatch. +type ISwitch_search_condition_sectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + Search_condition() ISearch_conditionContext + THEN() antlr.TerminalNode + Expr() IExprContext + + // IsSwitch_search_condition_sectionContext differentiates from other interfaces. + IsSwitch_search_condition_sectionContext() +} + +type Switch_search_condition_sectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySwitch_search_condition_sectionContext() *Switch_search_condition_sectionContext { + var p = new(Switch_search_condition_sectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_switch_search_condition_section + return p +} + +func InitEmptySwitch_search_condition_sectionContext(p *Switch_search_condition_sectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_switch_search_condition_section +} + +func (*Switch_search_condition_sectionContext) IsSwitch_search_condition_sectionContext() {} + +func NewSwitch_search_condition_sectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_search_condition_sectionContext { + var p = new(Switch_search_condition_sectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_switch_search_condition_section + + return p +} + +func (s *Switch_search_condition_sectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Switch_search_condition_sectionContext) WHEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHEN, 0) +} + +func (s *Switch_search_condition_sectionContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Switch_search_condition_sectionContext) THEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTHEN, 0) +} + +func (s *Switch_search_condition_sectionContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Switch_search_condition_sectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Switch_search_condition_sectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Switch_search_condition_sectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSwitch_search_condition_section(s) + } +} + +func (s *Switch_search_condition_sectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSwitch_search_condition_section(s) + } +} + +func (s *Switch_search_condition_sectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSwitch_search_condition_section(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Switch_search_condition_section() (localctx ISwitch_search_condition_sectionContext) { + localctx = NewSwitch_search_condition_sectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 928, SnowflakeParserRULE_switch_search_condition_section) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11092) + p.Match(SnowflakeParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11093) + p.search_condition(0) + } + { + p.SetState(11094) + p.Match(SnowflakeParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11095) + p.expr(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISwitch_sectionContext is an interface to support dynamic dispatch. +type ISwitch_sectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + THEN() antlr.TerminalNode + + // IsSwitch_sectionContext differentiates from other interfaces. + IsSwitch_sectionContext() +} + +type Switch_sectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySwitch_sectionContext() *Switch_sectionContext { + var p = new(Switch_sectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_switch_section + return p +} + +func InitEmptySwitch_sectionContext(p *Switch_sectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_switch_section +} + +func (*Switch_sectionContext) IsSwitch_sectionContext() {} + +func NewSwitch_sectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_sectionContext { + var p = new(Switch_sectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_switch_section + + return p +} + +func (s *Switch_sectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Switch_sectionContext) WHEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHEN, 0) +} + +func (s *Switch_sectionContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Switch_sectionContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Switch_sectionContext) THEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTHEN, 0) +} + +func (s *Switch_sectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Switch_sectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Switch_sectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSwitch_section(s) + } +} + +func (s *Switch_sectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSwitch_section(s) + } +} + +func (s *Switch_sectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSwitch_section(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Switch_section() (localctx ISwitch_sectionContext) { + localctx = NewSwitch_sectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 930, SnowflakeParserRULE_switch_section) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11097) + p.Match(SnowflakeParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11098) + p.expr(0) + } + { + p.SetState(11099) + p.Match(SnowflakeParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11100) + p.expr(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuery_statementContext is an interface to support dynamic dispatch. +type IQuery_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_statement() ISelect_statementContext + With_expression() IWith_expressionContext + AllSet_operators() []ISet_operatorsContext + Set_operators(i int) ISet_operatorsContext + + // IsQuery_statementContext differentiates from other interfaces. + IsQuery_statementContext() +} + +type Query_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_statementContext() *Query_statementContext { + var p = new(Query_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_query_statement + return p +} + +func InitEmptyQuery_statementContext(p *Query_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_query_statement +} + +func (*Query_statementContext) IsQuery_statementContext() {} + +func NewQuery_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_statementContext { + var p = new(Query_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_query_statement + + return p +} + +func (s *Query_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_statementContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Query_statementContext) With_expression() IWith_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_expressionContext) +} + +func (s *Query_statementContext) AllSet_operators() []ISet_operatorsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISet_operatorsContext); ok { + len++ + } + } + + tst := make([]ISet_operatorsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISet_operatorsContext); ok { + tst[i] = t.(ISet_operatorsContext) + i++ + } + } + + return tst +} + +func (s *Query_statementContext) Set_operators(i int) ISet_operatorsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_operatorsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISet_operatorsContext) +} + +func (s *Query_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterQuery_statement(s) + } +} + +func (s *Query_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitQuery_statement(s) + } +} + +func (s *Query_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitQuery_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Query_statement() (localctx IQuery_statementContext) { + localctx = NewQuery_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 932, SnowflakeParserRULE_query_statement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserWITH { + { + p.SetState(11102) + p.With_expression() + } + + } + { + p.SetState(11105) + p.Select_statement() + } + p.SetState(11109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1420, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11106) + p.Set_operators() + } + + } + p.SetState(11111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1420, 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 +} + +// IWith_expressionContext is an interface to support dynamic dispatch. +type IWith_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + AllCommon_table_expression() []ICommon_table_expressionContext + Common_table_expression(i int) ICommon_table_expressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsWith_expressionContext differentiates from other interfaces. + IsWith_expressionContext() +} + +type With_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWith_expressionContext() *With_expressionContext { + var p = new(With_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_with_expression + return p +} + +func InitEmptyWith_expressionContext(p *With_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_with_expression +} + +func (*With_expressionContext) IsWith_expressionContext() {} + +func NewWith_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_expressionContext { + var p = new(With_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_with_expression + + return p +} + +func (s *With_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_expressionContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *With_expressionContext) AllCommon_table_expression() []ICommon_table_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICommon_table_expressionContext); ok { + len++ + } + } + + tst := make([]ICommon_table_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICommon_table_expressionContext); ok { + tst[i] = t.(ICommon_table_expressionContext) + i++ + } + } + + return tst +} + +func (s *With_expressionContext) Common_table_expression(i int) ICommon_table_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommon_table_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICommon_table_expressionContext) +} + +func (s *With_expressionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *With_expressionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *With_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterWith_expression(s) + } +} + +func (s *With_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitWith_expression(s) + } +} + +func (s *With_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitWith_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) With_expression() (localctx IWith_expressionContext) { + localctx = NewWith_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 934, SnowflakeParserRULE_with_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11112) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11113) + p.Common_table_expression() + } + p.SetState(11118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11114) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11115) + p.Common_table_expression() + } + + p.SetState(11120) + 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_expressionContext is an interface to support dynamic dispatch. +type ICommon_table_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetColumns returns the columns rule contexts. + GetColumns() IColumn_listContext + + // SetColumns sets the columns rule contexts. + SetColumns(IColumn_listContext) + + // Getter signatures + Id_() IId_Context + AS() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Anchor_clause() IAnchor_clauseContext + UNION() antlr.TerminalNode + ALL() antlr.TerminalNode + Recursive_clause() IRecursive_clauseContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + RECURSIVE() antlr.TerminalNode + Column_list() IColumn_listContext + Query_statement() IQuery_statementContext + + // IsCommon_table_expressionContext differentiates from other interfaces. + IsCommon_table_expressionContext() +} + +type Common_table_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + columns IColumn_listContext +} + +func NewEmptyCommon_table_expressionContext() *Common_table_expressionContext { + var p = new(Common_table_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_common_table_expression + return p +} + +func InitEmptyCommon_table_expressionContext(p *Common_table_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_common_table_expression +} + +func (*Common_table_expressionContext) IsCommon_table_expressionContext() {} + +func NewCommon_table_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_table_expressionContext { + var p = new(Common_table_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_common_table_expression + + return p +} + +func (s *Common_table_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Common_table_expressionContext) GetColumns() IColumn_listContext { return s.columns } + +func (s *Common_table_expressionContext) SetColumns(v IColumn_listContext) { s.columns = v } + +func (s *Common_table_expressionContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Common_table_expressionContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *Common_table_expressionContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Common_table_expressionContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Common_table_expressionContext) Anchor_clause() IAnchor_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnchor_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnchor_clauseContext) +} + +func (s *Common_table_expressionContext) UNION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNION, 0) +} + +func (s *Common_table_expressionContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Common_table_expressionContext) Recursive_clause() IRecursive_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecursive_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecursive_clauseContext) +} + +func (s *Common_table_expressionContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Common_table_expressionContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Common_table_expressionContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECURSIVE, 0) +} + +func (s *Common_table_expressionContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Common_table_expressionContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *Common_table_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Common_table_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Common_table_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterCommon_table_expression(s) + } +} + +func (s *Common_table_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitCommon_table_expression(s) + } +} + +func (s *Common_table_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitCommon_table_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Common_table_expression() (localctx ICommon_table_expressionContext) { + localctx = NewCommon_table_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 936, SnowflakeParserRULE_common_table_expression) + var _la int + + p.SetState(11151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1425, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(11122) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1422, p.GetParserRuleContext()) == 1 { + { + p.SetState(11121) + p.Match(SnowflakeParserRECURSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11124) + p.Id_() + } + p.SetState(11129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(11125) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11126) + + var _x = p.Column_list() + + localctx.(*Common_table_expressionContext).columns = _x + } + { + p.SetState(11127) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11131) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11132) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11133) + p.Anchor_clause() + } + { + p.SetState(11134) + p.Match(SnowflakeParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11135) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11136) + p.Recursive_clause() + } + { + p.SetState(11137) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11139) + p.Id_() + } + p.SetState(11144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(11140) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11141) + + var _x = p.Column_list() + + localctx.(*Common_table_expressionContext).columns = _x + } + { + p.SetState(11142) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11146) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11147) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11148) + p.Query_statement() + } + { + p.SetState(11149) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// IAnchor_clauseContext is an interface to support dynamic dispatch. +type IAnchor_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_statement() IQuery_statementContext + + // IsAnchor_clauseContext differentiates from other interfaces. + IsAnchor_clauseContext() +} + +type Anchor_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnchor_clauseContext() *Anchor_clauseContext { + var p = new(Anchor_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_anchor_clause + return p +} + +func InitEmptyAnchor_clauseContext(p *Anchor_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_anchor_clause +} + +func (*Anchor_clauseContext) IsAnchor_clauseContext() {} + +func NewAnchor_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Anchor_clauseContext { + var p = new(Anchor_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_anchor_clause + + return p +} + +func (s *Anchor_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Anchor_clauseContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *Anchor_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Anchor_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Anchor_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAnchor_clause(s) + } +} + +func (s *Anchor_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAnchor_clause(s) + } +} + +func (s *Anchor_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAnchor_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Anchor_clause() (localctx IAnchor_clauseContext) { + localctx = NewAnchor_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 938, SnowflakeParserRULE_anchor_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11153) + p.Query_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecursive_clauseContext is an interface to support dynamic dispatch. +type IRecursive_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_statement() IQuery_statementContext + + // IsRecursive_clauseContext differentiates from other interfaces. + IsRecursive_clauseContext() +} + +type Recursive_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecursive_clauseContext() *Recursive_clauseContext { + var p = new(Recursive_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_recursive_clause + return p +} + +func InitEmptyRecursive_clauseContext(p *Recursive_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_recursive_clause +} + +func (*Recursive_clauseContext) IsRecursive_clauseContext() {} + +func NewRecursive_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recursive_clauseContext { + var p = new(Recursive_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_recursive_clause + + return p +} + +func (s *Recursive_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Recursive_clauseContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *Recursive_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Recursive_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Recursive_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRecursive_clause(s) + } +} + +func (s *Recursive_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRecursive_clause(s) + } +} + +func (s *Recursive_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRecursive_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Recursive_clause() (localctx IRecursive_clauseContext) { + localctx = NewRecursive_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 940, SnowflakeParserRULE_recursive_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11155) + p.Query_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_statementContext is an interface to support dynamic dispatch. +type ISelect_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_clause() ISelect_clauseContext + Select_optional_clauses() ISelect_optional_clausesContext + Limit_clause() ILimit_clauseContext + Select_top_clause() ISelect_top_clauseContext + + // IsSelect_statementContext differentiates from other interfaces. + IsSelect_statementContext() +} + +type Select_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_statementContext() *Select_statementContext { + var p = new(Select_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_statement + return p +} + +func InitEmptySelect_statementContext(p *Select_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_statement +} + +func (*Select_statementContext) IsSelect_statementContext() {} + +func NewSelect_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_statementContext { + var p = new(Select_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_select_statement + + return p +} + +func (s *Select_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_statementContext) 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_statementContext) Select_optional_clauses() ISelect_optional_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_optional_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_optional_clausesContext) +} + +func (s *Select_statementContext) 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_statementContext) Select_top_clause() ISelect_top_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_top_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_top_clauseContext) +} + +func (s *Select_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSelect_statement(s) + } +} + +func (s *Select_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSelect_statement(s) + } +} + +func (s *Select_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSelect_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Select_statement() (localctx ISelect_statementContext) { + localctx = NewSelect_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 942, SnowflakeParserRULE_select_statement) + p.SetState(11165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1427, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11157) + p.Select_clause() + } + { + p.SetState(11158) + p.Select_optional_clauses() + } + p.SetState(11160) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1426, p.GetParserRuleContext()) == 1 { + { + p.SetState(11159) + p.Limit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11162) + p.Select_top_clause() + } + { + p.SetState(11163) + p.Select_optional_clauses() + } + + 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 +} + +// ISet_operatorsContext is an interface to support dynamic dispatch. +type ISet_operatorsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_statement() ISelect_statementContext + UNION() antlr.TerminalNode + INTERSECT() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + MINUS_() antlr.TerminalNode + ALL() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + + // IsSet_operatorsContext differentiates from other interfaces. + IsSet_operatorsContext() +} + +type Set_operatorsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_operatorsContext() *Set_operatorsContext { + var p = new(Set_operatorsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_set_operators + return p +} + +func InitEmptySet_operatorsContext(p *Set_operatorsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_set_operators +} + +func (*Set_operatorsContext) IsSet_operatorsContext() {} + +func NewSet_operatorsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_operatorsContext { + var p = new(Set_operatorsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_set_operators + + return p +} + +func (s *Set_operatorsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_operatorsContext) Select_statement() ISelect_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_statementContext) +} + +func (s *Set_operatorsContext) UNION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNION, 0) +} + +func (s *Set_operatorsContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTERSECT, 0) +} + +func (s *Set_operatorsContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXCEPT, 0) +} + +func (s *Set_operatorsContext) MINUS_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINUS_, 0) +} + +func (s *Set_operatorsContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Set_operatorsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Set_operatorsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Set_operatorsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_operatorsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_operatorsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSet_operators(s) + } +} + +func (s *Set_operatorsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSet_operators(s) + } +} + +func (s *Set_operatorsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSet_operators(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Set_operators() (localctx ISet_operatorsContext) { + localctx = NewSet_operatorsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 944, SnowflakeParserRULE_set_operators) + var _la int + + p.SetState(11180) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserEXCEPT, SnowflakeParserINTERSECT, SnowflakeParserMINUS_, SnowflakeParserUNION: + p.EnterOuterAlt(localctx, 1) + p.SetState(11173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserUNION: + { + p.SetState(11167) + p.Match(SnowflakeParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALL { + { + p.SetState(11168) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case SnowflakeParserEXCEPT, SnowflakeParserMINUS_: + { + p.SetState(11171) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserEXCEPT || _la == SnowflakeParserMINUS_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserINTERSECT: + { + p.SetState(11172) + p.Match(SnowflakeParserINTERSECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11175) + p.Select_statement() + } + + case SnowflakeParserLR_BRACKET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11176) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11177) + p.Select_statement() + } + { + p.SetState(11178) + p.Match(SnowflakeParserRR_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 +} + +// ISelect_optional_clausesContext is an interface to support dynamic dispatch. +type ISelect_optional_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Into_clause() IInto_clauseContext + From_clause() IFrom_clauseContext + Where_clause() IWhere_clauseContext + Group_by_clause() IGroup_by_clauseContext + Qualify_clause() IQualify_clauseContext + Order_by_clause() IOrder_by_clauseContext + + // IsSelect_optional_clausesContext differentiates from other interfaces. + IsSelect_optional_clausesContext() +} + +type Select_optional_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_optional_clausesContext() *Select_optional_clausesContext { + var p = new(Select_optional_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_optional_clauses + return p +} + +func InitEmptySelect_optional_clausesContext(p *Select_optional_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_optional_clauses +} + +func (*Select_optional_clausesContext) IsSelect_optional_clausesContext() {} + +func NewSelect_optional_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_optional_clausesContext { + var p = new(Select_optional_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_select_optional_clauses + + return p +} + +func (s *Select_optional_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_optional_clausesContext) 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 *Select_optional_clausesContext) 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 *Select_optional_clausesContext) 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 *Select_optional_clausesContext) Group_by_clause() IGroup_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_clauseContext) +} + +func (s *Select_optional_clausesContext) Qualify_clause() IQualify_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualify_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQualify_clauseContext) +} + +func (s *Select_optional_clausesContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Select_optional_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_optional_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_optional_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSelect_optional_clauses(s) + } +} + +func (s *Select_optional_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSelect_optional_clauses(s) + } +} + +func (s *Select_optional_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSelect_optional_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Select_optional_clauses() (localctx ISelect_optional_clausesContext) { + localctx = NewSelect_optional_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 946, SnowflakeParserRULE_select_optional_clauses) + p.EnterOuterAlt(localctx, 1) + p.SetState(11183) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1431, p.GetParserRuleContext()) == 1 { + { + p.SetState(11182) + p.Into_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11186) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1432, p.GetParserRuleContext()) == 1 { + { + p.SetState(11185) + p.From_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11189) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1433, p.GetParserRuleContext()) == 1 { + { + p.SetState(11188) + p.Where_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11192) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1434, p.GetParserRuleContext()) == 1 { + { + p.SetState(11191) + p.Group_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11195) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1435, p.GetParserRuleContext()) == 1 { + { + p.SetState(11194) + p.Qualify_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11198) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1436, p.GetParserRuleContext()) == 1 { + { + p.SetState(11197) + p.Order_by_clause() + } + + } 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 +} + +// ISelect_clauseContext is an interface to support dynamic dispatch. +type ISelect_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + Select_list_no_top() ISelect_list_no_topContext + + // 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 = SnowflakeParserRULE_select_clause + return p +} + +func InitEmptySelect_clauseContext(p *Select_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_select_clause + + return p +} + +func (s *Select_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_clauseContext) SELECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSELECT, 0) +} + +func (s *Select_clauseContext) Select_list_no_top() ISelect_list_no_topContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_no_topContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_no_topContext) +} + +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.(SnowflakeParserListener); ok { + listenerT.EnterSelect_clause(s) + } +} + +func (s *Select_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSelect_clause(s) + } +} + +func (s *Select_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSelect_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Select_clause() (localctx ISelect_clauseContext) { + localctx = NewSelect_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 948, SnowflakeParserRULE_select_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11200) + p.Match(SnowflakeParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11201) + p.Select_list_no_top() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_top_clauseContext is an interface to support dynamic dispatch. +type ISelect_top_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + Select_list_top() ISelect_list_topContext + + // IsSelect_top_clauseContext differentiates from other interfaces. + IsSelect_top_clauseContext() +} + +type Select_top_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_top_clauseContext() *Select_top_clauseContext { + var p = new(Select_top_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_top_clause + return p +} + +func InitEmptySelect_top_clauseContext(p *Select_top_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_top_clause +} + +func (*Select_top_clauseContext) IsSelect_top_clauseContext() {} + +func NewSelect_top_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_top_clauseContext { + var p = new(Select_top_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_select_top_clause + + return p +} + +func (s *Select_top_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_top_clauseContext) SELECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSELECT, 0) +} + +func (s *Select_top_clauseContext) Select_list_top() ISelect_list_topContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_topContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_topContext) +} + +func (s *Select_top_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_top_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_top_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSelect_top_clause(s) + } +} + +func (s *Select_top_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSelect_top_clause(s) + } +} + +func (s *Select_top_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSelect_top_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Select_top_clause() (localctx ISelect_top_clauseContext) { + localctx = NewSelect_top_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 950, SnowflakeParserRULE_select_top_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11203) + p.Match(SnowflakeParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11204) + p.Select_list_top() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_list_no_topContext is an interface to support dynamic dispatch. +type ISelect_list_no_topContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_list() ISelect_listContext + All_distinct() IAll_distinctContext + + // IsSelect_list_no_topContext differentiates from other interfaces. + IsSelect_list_no_topContext() +} + +type Select_list_no_topContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_list_no_topContext() *Select_list_no_topContext { + var p = new(Select_list_no_topContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_list_no_top + return p +} + +func InitEmptySelect_list_no_topContext(p *Select_list_no_topContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_list_no_top +} + +func (*Select_list_no_topContext) IsSelect_list_no_topContext() {} + +func NewSelect_list_no_topContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_no_topContext { + var p = new(Select_list_no_topContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_select_list_no_top + + return p +} + +func (s *Select_list_no_topContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_list_no_topContext) Select_list() ISelect_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_listContext) +} + +func (s *Select_list_no_topContext) All_distinct() IAll_distinctContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_distinctContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_distinctContext) +} + +func (s *Select_list_no_topContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_list_no_topContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_list_no_topContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSelect_list_no_top(s) + } +} + +func (s *Select_list_no_topContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSelect_list_no_top(s) + } +} + +func (s *Select_list_no_topContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSelect_list_no_top(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Select_list_no_top() (localctx ISelect_list_no_topContext) { + localctx = NewSelect_list_no_topContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 952, SnowflakeParserRULE_select_list_no_top) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALL || _la == SnowflakeParserDISTINCT { + { + p.SetState(11206) + p.All_distinct() + } + + } + { + p.SetState(11209) + p.Select_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 +} + +// ISelect_list_topContext is an interface to support dynamic dispatch. +type ISelect_list_topContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Top_clause() ITop_clauseContext + Select_list() ISelect_listContext + All_distinct() IAll_distinctContext + + // IsSelect_list_topContext differentiates from other interfaces. + IsSelect_list_topContext() +} + +type Select_list_topContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_list_topContext() *Select_list_topContext { + var p = new(Select_list_topContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_list_top + return p +} + +func InitEmptySelect_list_topContext(p *Select_list_topContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_list_top +} + +func (*Select_list_topContext) IsSelect_list_topContext() {} + +func NewSelect_list_topContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_topContext { + var p = new(Select_list_topContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_select_list_top + + return p +} + +func (s *Select_list_topContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_list_topContext) Top_clause() ITop_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITop_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITop_clauseContext) +} + +func (s *Select_list_topContext) Select_list() ISelect_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_listContext) +} + +func (s *Select_list_topContext) All_distinct() IAll_distinctContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_distinctContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_distinctContext) +} + +func (s *Select_list_topContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_list_topContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_list_topContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSelect_list_top(s) + } +} + +func (s *Select_list_topContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSelect_list_top(s) + } +} + +func (s *Select_list_topContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSelect_list_top(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Select_list_top() (localctx ISelect_list_topContext) { + localctx = NewSelect_list_topContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 954, SnowflakeParserRULE_select_list_top) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALL || _la == SnowflakeParserDISTINCT { + { + p.SetState(11211) + p.All_distinct() + } + + } + { + p.SetState(11214) + p.Top_clause() + } + { + p.SetState(11215) + p.Select_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 +} + +// ISelect_listContext is an interface to support dynamic dispatch. +type ISelect_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSelect_list_elem() []ISelect_list_elemContext + Select_list_elem(i int) ISelect_list_elemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSelect_listContext differentiates from other interfaces. + IsSelect_listContext() +} + +type Select_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_listContext() *Select_listContext { + var p = new(Select_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_list + return p +} + +func InitEmptySelect_listContext(p *Select_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_list +} + +func (*Select_listContext) IsSelect_listContext() {} + +func NewSelect_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_listContext { + var p = new(Select_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_select_list + + return p +} + +func (s *Select_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_listContext) AllSelect_list_elem() []ISelect_list_elemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelect_list_elemContext); ok { + len++ + } + } + + tst := make([]ISelect_list_elemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelect_list_elemContext); ok { + tst[i] = t.(ISelect_list_elemContext) + i++ + } + } + + return tst +} + +func (s *Select_listContext) Select_list_elem(i int) ISelect_list_elemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_elemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_elemContext) +} + +func (s *Select_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Select_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Select_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSelect_list(s) + } +} + +func (s *Select_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSelect_list(s) + } +} + +func (s *Select_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSelect_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Select_list() (localctx ISelect_listContext) { + localctx = NewSelect_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 956, SnowflakeParserRULE_select_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11217) + p.Select_list_elem() + } + p.SetState(11222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1439, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11218) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11219) + p.Select_list_elem() + } + + } + p.SetState(11224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1439, 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 +} + +// ISelect_list_elemContext is an interface to support dynamic dispatch. +type ISelect_list_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_elem() IColumn_elemContext + Expression_elem() IExpression_elemContext + + // IsSelect_list_elemContext differentiates from other interfaces. + IsSelect_list_elemContext() +} + +type Select_list_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_list_elemContext() *Select_list_elemContext { + var p = new(Select_list_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_list_elem + return p +} + +func InitEmptySelect_list_elemContext(p *Select_list_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_select_list_elem +} + +func (*Select_list_elemContext) IsSelect_list_elemContext() {} + +func NewSelect_list_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_elemContext { + var p = new(Select_list_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_select_list_elem + + return p +} + +func (s *Select_list_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_list_elemContext) Column_elem() IColumn_elemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_elemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_elemContext) +} + +func (s *Select_list_elemContext) Expression_elem() IExpression_elemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpression_elemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpression_elemContext) +} + +func (s *Select_list_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_list_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_list_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSelect_list_elem(s) + } +} + +func (s *Select_list_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSelect_list_elem(s) + } +} + +func (s *Select_list_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSelect_list_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Select_list_elem() (localctx ISelect_list_elemContext) { + localctx = NewSelect_list_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 958, SnowflakeParserRULE_select_list_elem) + p.SetState(11227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1440, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11225) + p.Column_elem() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11226) + p.Expression_elem() + } + + 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 +} + +// IColumn_elemContext is an interface to support dynamic dispatch. +type IColumn_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STAR() antlr.TerminalNode + Object_name() IObject_nameContext + Alias() IAliasContext + DOT() antlr.TerminalNode + Column_name() IColumn_nameContext + As_alias() IAs_aliasContext + DOLLAR() antlr.TerminalNode + Column_position() IColumn_positionContext + + // IsColumn_elemContext differentiates from other interfaces. + IsColumn_elemContext() +} + +type Column_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_elemContext() *Column_elemContext { + var p = new(Column_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_elem + return p +} + +func InitEmptyColumn_elemContext(p *Column_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_elem +} + +func (*Column_elemContext) IsColumn_elemContext() {} + +func NewColumn_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_elemContext { + var p = new(Column_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_elem + + return p +} + +func (s *Column_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_elemContext) STAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAR, 0) +} + +func (s *Column_elemContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Column_elemContext) Alias() IAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAliasContext) +} + +func (s *Column_elemContext) DOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOT, 0) +} + +func (s *Column_elemContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Column_elemContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Column_elemContext) DOLLAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOLLAR, 0) +} + +func (s *Column_elemContext) Column_position() IColumn_positionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_positionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_positionContext) +} + +func (s *Column_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_elem(s) + } +} + +func (s *Column_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_elem(s) + } +} + +func (s *Column_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_elem() (localctx IColumn_elemContext) { + localctx = NewColumn_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 960, SnowflakeParserRULE_column_elem) + p.SetState(11257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1446, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(11233) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1441, p.GetParserRuleContext()) == 1 { + { + p.SetState(11229) + p.Object_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1441, p.GetParserRuleContext()) == 2 { + { + p.SetState(11230) + p.Alias() + } + { + p.SetState(11231) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11235) + p.Match(SnowflakeParserSTAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(11240) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1442, p.GetParserRuleContext()) == 1 { + { + p.SetState(11236) + p.Object_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1442, p.GetParserRuleContext()) == 2 { + { + p.SetState(11237) + p.Alias() + } + { + p.SetState(11238) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11242) + p.Column_name() + } + p.SetState(11244) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1443, p.GetParserRuleContext()) == 1 { + { + p.SetState(11243) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + p.SetState(11250) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1444, p.GetParserRuleContext()) == 1 { + { + p.SetState(11246) + p.Object_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1444, p.GetParserRuleContext()) == 2 { + { + p.SetState(11247) + p.Alias() + } + { + p.SetState(11248) + p.Match(SnowflakeParserDOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11252) + p.Match(SnowflakeParserDOLLAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11253) + p.Column_position() + } + p.SetState(11255) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1445, p.GetParserRuleContext()) == 1 { + { + p.SetState(11254) + p.As_alias() + } + + } 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 +} + +// IAs_aliasContext is an interface to support dynamic dispatch. +type IAs_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alias() IAliasContext + AS() antlr.TerminalNode + + // IsAs_aliasContext differentiates from other interfaces. + IsAs_aliasContext() +} + +type As_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAs_aliasContext() *As_aliasContext { + var p = new(As_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_as_alias + return p +} + +func InitEmptyAs_aliasContext(p *As_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_as_alias +} + +func (*As_aliasContext) IsAs_aliasContext() {} + +func NewAs_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *As_aliasContext { + var p = new(As_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_as_alias + + return p +} + +func (s *As_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *As_aliasContext) Alias() IAliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAliasContext) +} + +func (s *As_aliasContext) AS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, 0) +} + +func (s *As_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *As_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *As_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAs_alias(s) + } +} + +func (s *As_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAs_alias(s) + } +} + +func (s *As_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAs_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) As_alias() (localctx IAs_aliasContext) { + localctx = NewAs_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 962, SnowflakeParserRULE_as_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAS { + { + p.SetState(11259) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11262) + p.Alias() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpression_elemContext is an interface to support dynamic dispatch. +type IExpression_elemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expr() IExprContext + Predicate() IPredicateContext + As_alias() IAs_aliasContext + + // IsExpression_elemContext differentiates from other interfaces. + IsExpression_elemContext() +} + +type Expression_elemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpression_elemContext() *Expression_elemContext { + var p = new(Expression_elemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expression_elem + return p +} + +func InitEmptyExpression_elemContext(p *Expression_elemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expression_elem +} + +func (*Expression_elemContext) IsExpression_elemContext() {} + +func NewExpression_elemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expression_elemContext { + var p = new(Expression_elemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_expression_elem + + return p +} + +func (s *Expression_elemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expression_elemContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Expression_elemContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *Expression_elemContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Expression_elemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expression_elemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expression_elemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExpression_elem(s) + } +} + +func (s *Expression_elemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExpression_elem(s) + } +} + +func (s *Expression_elemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExpression_elem(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Expression_elem() (localctx IExpression_elemContext) { + localctx = NewExpression_elemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 964, SnowflakeParserRULE_expression_elem) + p.EnterOuterAlt(localctx, 1) + p.SetState(11266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1448, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11264) + p.expr(0) + } + + case 2: + { + p.SetState(11265) + p.Predicate() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(11269) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1449, p.GetParserRuleContext()) == 1 { + { + p.SetState(11268) + p.As_alias() + } + + } 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 +} + +// IColumn_positionContext is an interface to support dynamic dispatch. +type IColumn_positionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Num() INumContext + + // IsColumn_positionContext differentiates from other interfaces. + IsColumn_positionContext() +} + +type Column_positionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_positionContext() *Column_positionContext { + var p = new(Column_positionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_position + return p +} + +func InitEmptyColumn_positionContext(p *Column_positionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_position +} + +func (*Column_positionContext) IsColumn_positionContext() {} + +func NewColumn_positionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_positionContext { + var p = new(Column_positionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_position + + return p +} + +func (s *Column_positionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_positionContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Column_positionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_positionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_positionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_position(s) + } +} + +func (s *Column_positionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_position(s) + } +} + +func (s *Column_positionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_position(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_position() (localctx IColumn_positionContext) { + localctx = NewColumn_positionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 966, SnowflakeParserRULE_column_position) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11271) + p.Num() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_distinctContext is an interface to support dynamic dispatch. +type IAll_distinctContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + + // IsAll_distinctContext differentiates from other interfaces. + IsAll_distinctContext() +} + +type All_distinctContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_distinctContext() *All_distinctContext { + var p = new(All_distinctContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_all_distinct + return p +} + +func InitEmptyAll_distinctContext(p *All_distinctContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_all_distinct +} + +func (*All_distinctContext) IsAll_distinctContext() {} + +func NewAll_distinctContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_distinctContext { + var p = new(All_distinctContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_all_distinct + + return p +} + +func (s *All_distinctContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_distinctContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *All_distinctContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISTINCT, 0) +} + +func (s *All_distinctContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_distinctContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_distinctContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAll_distinct(s) + } +} + +func (s *All_distinctContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAll_distinct(s) + } +} + +func (s *All_distinctContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAll_distinct(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) All_distinct() (localctx IAll_distinctContext) { + localctx = NewAll_distinctContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 968, SnowflakeParserRULE_all_distinct) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11273) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserALL || _la == SnowflakeParserDISTINCT) { + 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 +} + +// ITop_clauseContext is an interface to support dynamic dispatch. +type ITop_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TOP() antlr.TerminalNode + Num() INumContext + + // IsTop_clauseContext differentiates from other interfaces. + IsTop_clauseContext() +} + +type Top_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTop_clauseContext() *Top_clauseContext { + var p = new(Top_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_top_clause + return p +} + +func InitEmptyTop_clauseContext(p *Top_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_top_clause +} + +func (*Top_clauseContext) IsTop_clauseContext() {} + +func NewTop_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Top_clauseContext { + var p = new(Top_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_top_clause + + return p +} + +func (s *Top_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Top_clauseContext) TOP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTOP, 0) +} + +func (s *Top_clauseContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Top_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Top_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Top_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTop_clause(s) + } +} + +func (s *Top_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTop_clause(s) + } +} + +func (s *Top_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTop_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Top_clause() (localctx ITop_clauseContext) { + localctx = NewTop_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 970, SnowflakeParserRULE_top_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11275) + p.Match(SnowflakeParserTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11276) + p.Num() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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 + Var_list() IVar_listContext + + // 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 = SnowflakeParserRULE_into_clause + return p +} + +func InitEmptyInto_clauseContext(p *Into_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_into_clause + + return p +} + +func (s *Into_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Into_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTO, 0) +} + +func (s *Into_clauseContext) 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 *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.(SnowflakeParserListener); ok { + listenerT.EnterInto_clause(s) + } +} + +func (s *Into_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitInto_clause(s) + } +} + +func (s *Into_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitInto_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Into_clause() (localctx IInto_clauseContext) { + localctx = NewInto_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 972, SnowflakeParserRULE_into_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11278) + p.Match(SnowflakeParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11279) + 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 +} + +// 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_() []IVarContext + Var_(i int) IVarContext + COMMA() 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 = SnowflakeParserRULE_var_list + return p +} + +func InitEmptyVar_listContext(p *Var_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_var_list + + return p +} + +func (s *Var_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Var_listContext) AllVar_() []IVarContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarContext); ok { + len++ + } + } + + tst := make([]IVarContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarContext); ok { + tst[i] = t.(IVarContext) + i++ + } + } + + return tst +} + +func (s *Var_listContext) Var_(i int) IVarContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarContext) +} + +func (s *Var_listContext) COMMA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, 0) +} + +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.(SnowflakeParserListener); ok { + listenerT.EnterVar_list(s) + } +} + +func (s *Var_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitVar_list(s) + } +} + +func (s *Var_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitVar_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Var_list() (localctx IVar_listContext) { + localctx = NewVar_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 974, SnowflakeParserRULE_var_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11281) + p.Var_() + } + + { + p.SetState(11282) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11283) + p.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 +} + +// IVarContext is an interface to support dynamic dispatch. +type IVarContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLON() antlr.TerminalNode + Id_() IId_Context + + // IsVarContext differentiates from other interfaces. + IsVarContext() +} + +type VarContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarContext() *VarContext { + var p = new(VarContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_var + return p +} + +func InitEmptyVarContext(p *VarContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_var +} + +func (*VarContext) IsVarContext() {} + +func NewVarContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VarContext { + var p = new(VarContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_var + + return p +} + +func (s *VarContext) GetParser() antlr.Parser { return s.parser } + +func (s *VarContext) COLON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLON, 0) +} + +func (s *VarContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *VarContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *VarContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *VarContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterVar(s) + } +} + +func (s *VarContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitVar(s) + } +} + +func (s *VarContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitVar(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Var_() (localctx IVarContext) { + localctx = NewVarContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 976, SnowflakeParserRULE_var) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11285) + p.Match(SnowflakeParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11286) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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 + Table_sources() ITable_sourcesContext + + // 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 = SnowflakeParserRULE_from_clause + return p +} + +func InitEmptyFrom_clauseContext(p *From_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_from_clause + + return p +} + +func (s *From_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_clauseContext) FROM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFROM, 0) +} + +func (s *From_clauseContext) Table_sources() ITable_sourcesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourcesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourcesContext) +} + +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.(SnowflakeParserListener); ok { + listenerT.EnterFrom_clause(s) + } +} + +func (s *From_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFrom_clause(s) + } +} + +func (s *From_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFrom_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) From_clause() (localctx IFrom_clauseContext) { + localctx = NewFrom_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 978, SnowflakeParserRULE_from_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11288) + p.Match(SnowflakeParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11289) + p.Table_sources() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_sourcesContext is an interface to support dynamic dispatch. +type ITable_sourcesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTable_source() []ITable_sourceContext + Table_source(i int) ITable_sourceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_sourcesContext differentiates from other interfaces. + IsTable_sourcesContext() +} + +type Table_sourcesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_sourcesContext() *Table_sourcesContext { + var p = new(Table_sourcesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_sources + return p +} + +func InitEmptyTable_sourcesContext(p *Table_sourcesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_sources +} + +func (*Table_sourcesContext) IsTable_sourcesContext() {} + +func NewTable_sourcesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_sourcesContext { + var p = new(Table_sourcesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_table_sources + + return p +} + +func (s *Table_sourcesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_sourcesContext) AllTable_source() []ITable_sourceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_sourceContext); ok { + len++ + } + } + + tst := make([]ITable_sourceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_sourceContext); ok { + tst[i] = t.(ITable_sourceContext) + i++ + } + } + + return tst +} + +func (s *Table_sourcesContext) Table_source(i int) ITable_sourceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_sourceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_sourceContext) +} + +func (s *Table_sourcesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Table_sourcesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Table_sourcesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_sourcesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_sourcesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTable_sources(s) + } +} + +func (s *Table_sourcesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTable_sources(s) + } +} + +func (s *Table_sourcesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTable_sources(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Table_sources() (localctx ITable_sourcesContext) { + localctx = NewTable_sourcesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 980, SnowflakeParserRULE_table_sources) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11291) + p.Table_source() + } + p.SetState(11296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1450, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11292) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11293) + p.Table_source() + } + + } + p.SetState(11298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1450, 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_sourceContext is an interface to support dynamic dispatch. +type ITable_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_source_item_joined() ITable_source_item_joinedContext + + // IsTable_sourceContext differentiates from other interfaces. + IsTable_sourceContext() +} + +type Table_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_sourceContext() *Table_sourceContext { + var p = new(Table_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_source + return p +} + +func InitEmptyTable_sourceContext(p *Table_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_source +} + +func (*Table_sourceContext) IsTable_sourceContext() {} + +func NewTable_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_sourceContext { + var p = new(Table_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_table_source + + return p +} + +func (s *Table_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_sourceContext) Table_source_item_joined() ITable_source_item_joinedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_source_item_joinedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_source_item_joinedContext) +} + +func (s *Table_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTable_source(s) + } +} + +func (s *Table_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTable_source(s) + } +} + +func (s *Table_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTable_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Table_source() (localctx ITable_sourceContext) { + localctx = NewTable_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 982, SnowflakeParserRULE_table_source) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11299) + p.Table_source_item_joined() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_source_item_joinedContext is an interface to support dynamic dispatch. +type ITable_source_item_joinedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Object_ref() IObject_refContext + AllJoin_clause() []IJoin_clauseContext + Join_clause(i int) IJoin_clauseContext + LR_BRACKET() antlr.TerminalNode + Table_source_item_joined() ITable_source_item_joinedContext + RR_BRACKET() antlr.TerminalNode + + // IsTable_source_item_joinedContext differentiates from other interfaces. + IsTable_source_item_joinedContext() +} + +type Table_source_item_joinedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_source_item_joinedContext() *Table_source_item_joinedContext { + var p = new(Table_source_item_joinedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_source_item_joined + return p +} + +func InitEmptyTable_source_item_joinedContext(p *Table_source_item_joinedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_table_source_item_joined +} + +func (*Table_source_item_joinedContext) IsTable_source_item_joinedContext() {} + +func NewTable_source_item_joinedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_source_item_joinedContext { + var p = new(Table_source_item_joinedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_table_source_item_joined + + return p +} + +func (s *Table_source_item_joinedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_source_item_joinedContext) Object_ref() IObject_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_refContext) +} + +func (s *Table_source_item_joinedContext) AllJoin_clause() []IJoin_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_clauseContext); ok { + len++ + } + } + + tst := make([]IJoin_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_clauseContext); ok { + tst[i] = t.(IJoin_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_source_item_joinedContext) Join_clause(i int) IJoin_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_clauseContext) +} + +func (s *Table_source_item_joinedContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Table_source_item_joinedContext) Table_source_item_joined() ITable_source_item_joinedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_source_item_joinedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_source_item_joinedContext) +} + +func (s *Table_source_item_joinedContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Table_source_item_joinedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_source_item_joinedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_source_item_joinedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterTable_source_item_joined(s) + } +} + +func (s *Table_source_item_joinedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitTable_source_item_joined(s) + } +} + +func (s *Table_source_item_joinedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitTable_source_item_joined(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Table_source_item_joined() (localctx ITable_source_item_joinedContext) { + localctx = NewTable_source_item_joinedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 984, SnowflakeParserRULE_table_source_item_joined) + var _alt int + + p.SetState(11317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1453, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11301) + p.Object_ref() + } + p.SetState(11305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1451, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11302) + p.Join_clause() + } + + } + p.SetState(11307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1451, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11308) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11309) + p.Table_source_item_joined() + } + { + p.SetState(11310) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1452, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11311) + p.Join_clause() + } + + } + p.SetState(11316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1452, 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 +} + +// IObject_refContext is an interface to support dynamic dispatch. +type IObject_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Object_name() IObject_nameContext + At_before() IAt_beforeContext + Changes() IChangesContext + Match_recognize() IMatch_recognizeContext + Pivot_unpivot() IPivot_unpivotContext + As_alias() IAs_aliasContext + Sample() ISampleContext + START() antlr.TerminalNode + WITH() antlr.TerminalNode + Predicate() IPredicateContext + CONNECT() antlr.TerminalNode + BY() antlr.TerminalNode + Prior_list() IPrior_listContext + TABLE() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + Expr_list() IExpr_listContext + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + Values() IValuesContext + Subquery() ISubqueryContext + LATERAL() antlr.TerminalNode + Flatten_table() IFlatten_tableContext + + // IsObject_refContext differentiates from other interfaces. + IsObject_refContext() +} + +type Object_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_refContext() *Object_refContext { + var p = new(Object_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_ref + return p +} + +func InitEmptyObject_refContext(p *Object_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_object_ref +} + +func (*Object_refContext) IsObject_refContext() {} + +func NewObject_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_refContext { + var p = new(Object_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_object_ref + + return p +} + +func (s *Object_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_refContext) Object_name() IObject_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_nameContext) +} + +func (s *Object_refContext) At_before() IAt_beforeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAt_beforeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAt_beforeContext) +} + +func (s *Object_refContext) Changes() IChangesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChangesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChangesContext) +} + +func (s *Object_refContext) Match_recognize() IMatch_recognizeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMatch_recognizeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMatch_recognizeContext) +} + +func (s *Object_refContext) Pivot_unpivot() IPivot_unpivotContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_unpivotContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_unpivotContext) +} + +func (s *Object_refContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *Object_refContext) Sample() ISampleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISampleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISampleContext) +} + +func (s *Object_refContext) START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTART, 0) +} + +func (s *Object_refContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Object_refContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *Object_refContext) CONNECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONNECT, 0) +} + +func (s *Object_refContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Object_refContext) Prior_list() IPrior_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrior_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrior_listContext) +} + +func (s *Object_refContext) TABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE, 0) +} + +func (s *Object_refContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Object_refContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Object_refContext) 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 *Object_refContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Object_refContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Object_refContext) Values() IValuesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValuesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValuesContext) +} + +func (s *Object_refContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *Object_refContext) LATERAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLATERAL, 0) +} + +func (s *Object_refContext) Flatten_table() IFlatten_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlatten_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlatten_tableContext) +} + +func (s *Object_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterObject_ref(s) + } +} + +func (s *Object_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitObject_ref(s) + } +} + +func (s *Object_refContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitObject_ref(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Object_ref() (localctx IObject_refContext) { + localctx = NewObject_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 986, SnowflakeParserRULE_object_ref) + var _la int + + p.SetState(11386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1469, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11319) + p.Object_name() + } + p.SetState(11321) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1454, p.GetParserRuleContext()) == 1 { + { + p.SetState(11320) + p.At_before() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11324) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1455, p.GetParserRuleContext()) == 1 { + { + p.SetState(11323) + p.Changes() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11327) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1456, p.GetParserRuleContext()) == 1 { + { + p.SetState(11326) + p.Match_recognize() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11330) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1457, p.GetParserRuleContext()) == 1 { + { + p.SetState(11329) + p.Pivot_unpivot() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11333) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1458, p.GetParserRuleContext()) == 1 { + { + p.SetState(11332) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11336) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1459, p.GetParserRuleContext()) == 1 { + { + p.SetState(11335) + p.Sample() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11338) + p.Object_name() + } + { + p.SetState(11339) + p.Match(SnowflakeParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11340) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11341) + p.Predicate() + } + { + p.SetState(11342) + p.Match(SnowflakeParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11343) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11345) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1460, p.GetParserRuleContext()) == 1 { + { + p.SetState(11344) + p.Prior_list() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11347) + p.Match(SnowflakeParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11348) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11349) + p.Object_name() + } + { + p.SetState(11350) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11351) + p.Expr_list() + } + { + p.SetState(11352) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11353) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11355) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1461, p.GetParserRuleContext()) == 1 { + { + p.SetState(11354) + p.Pivot_unpivot() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11358) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1462, p.GetParserRuleContext()) == 1 { + { + p.SetState(11357) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11361) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1463, p.GetParserRuleContext()) == 1 { + { + p.SetState(11360) + p.Sample() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11363) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11364) + p.Values() + } + { + p.SetState(11365) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11367) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1464, p.GetParserRuleContext()) == 1 { + { + p.SetState(11366) + p.Sample() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + p.SetState(11370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLATERAL { + { + p.SetState(11369) + p.Match(SnowflakeParserLATERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11372) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11373) + p.Subquery() + } + { + p.SetState(11374) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11376) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1466, p.GetParserRuleContext()) == 1 { + { + p.SetState(11375) + p.Pivot_unpivot() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11379) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1467, p.GetParserRuleContext()) == 1 { + { + p.SetState(11378) + p.As_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11381) + p.Match(SnowflakeParserLATERAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11382) + p.Flatten_table() + } + p.SetState(11384) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1468, p.GetParserRuleContext()) == 1 { + { + p.SetState(11383) + p.As_alias() + } + + } 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 +} + +// IFlatten_table_optionContext is an interface to support dynamic dispatch. +type IFlatten_table_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PATH_() antlr.TerminalNode + ASSOC() antlr.TerminalNode + String_() IStringContext + OUTER() antlr.TerminalNode + True_false() ITrue_falseContext + RECURSIVE() antlr.TerminalNode + MODE() antlr.TerminalNode + ARRAY_Q() antlr.TerminalNode + OBJECT_Q() antlr.TerminalNode + BOTH_Q() antlr.TerminalNode + + // IsFlatten_table_optionContext differentiates from other interfaces. + IsFlatten_table_optionContext() +} + +type Flatten_table_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlatten_table_optionContext() *Flatten_table_optionContext { + var p = new(Flatten_table_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_flatten_table_option + return p +} + +func InitEmptyFlatten_table_optionContext(p *Flatten_table_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_flatten_table_option +} + +func (*Flatten_table_optionContext) IsFlatten_table_optionContext() {} + +func NewFlatten_table_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flatten_table_optionContext { + var p = new(Flatten_table_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_flatten_table_option + + return p +} + +func (s *Flatten_table_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flatten_table_optionContext) PATH_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPATH_, 0) +} + +func (s *Flatten_table_optionContext) ASSOC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASSOC, 0) +} + +func (s *Flatten_table_optionContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *Flatten_table_optionContext) OUTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOUTER, 0) +} + +func (s *Flatten_table_optionContext) True_false() ITrue_falseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrue_falseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrue_falseContext) +} + +func (s *Flatten_table_optionContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECURSIVE, 0) +} + +func (s *Flatten_table_optionContext) MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODE, 0) +} + +func (s *Flatten_table_optionContext) ARRAY_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARRAY_Q, 0) +} + +func (s *Flatten_table_optionContext) OBJECT_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT_Q, 0) +} + +func (s *Flatten_table_optionContext) BOTH_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBOTH_Q, 0) +} + +func (s *Flatten_table_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flatten_table_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flatten_table_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFlatten_table_option(s) + } +} + +func (s *Flatten_table_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFlatten_table_option(s) + } +} + +func (s *Flatten_table_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFlatten_table_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Flatten_table_option() (localctx IFlatten_table_optionContext) { + localctx = NewFlatten_table_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 988, SnowflakeParserRULE_flatten_table_option) + var _la int + + p.SetState(11400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserPATH_: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11388) + p.Match(SnowflakeParserPATH_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11389) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11390) + p.String_() + } + + case SnowflakeParserOUTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11391) + p.Match(SnowflakeParserOUTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11392) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11393) + p.True_false() + } + + case SnowflakeParserRECURSIVE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11394) + p.Match(SnowflakeParserRECURSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11395) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11396) + p.True_false() + } + + case SnowflakeParserMODE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11397) + p.Match(SnowflakeParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11398) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11399) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserBOTH_Q || _la == SnowflakeParserOBJECT_Q || _la == SnowflakeParserARRAY_Q) { + 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 +} + +// IFlatten_tableContext is an interface to support dynamic dispatch. +type IFlatten_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FLATTEN() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Expr() IExprContext + RR_BRACKET() antlr.TerminalNode + INPUT() antlr.TerminalNode + ASSOC() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllFlatten_table_option() []IFlatten_table_optionContext + Flatten_table_option(i int) IFlatten_table_optionContext + + // IsFlatten_tableContext differentiates from other interfaces. + IsFlatten_tableContext() +} + +type Flatten_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlatten_tableContext() *Flatten_tableContext { + var p = new(Flatten_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_flatten_table + return p +} + +func InitEmptyFlatten_tableContext(p *Flatten_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_flatten_table +} + +func (*Flatten_tableContext) IsFlatten_tableContext() {} + +func NewFlatten_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flatten_tableContext { + var p = new(Flatten_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_flatten_table + + return p +} + +func (s *Flatten_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flatten_tableContext) FLATTEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFLATTEN, 0) +} + +func (s *Flatten_tableContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Flatten_tableContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Flatten_tableContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Flatten_tableContext) INPUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINPUT, 0) +} + +func (s *Flatten_tableContext) ASSOC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASSOC, 0) +} + +func (s *Flatten_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Flatten_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Flatten_tableContext) AllFlatten_table_option() []IFlatten_table_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFlatten_table_optionContext); ok { + len++ + } + } + + tst := make([]IFlatten_table_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFlatten_table_optionContext); ok { + tst[i] = t.(IFlatten_table_optionContext) + i++ + } + } + + return tst +} + +func (s *Flatten_tableContext) Flatten_table_option(i int) IFlatten_table_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlatten_table_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFlatten_table_optionContext) +} + +func (s *Flatten_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flatten_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flatten_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFlatten_table(s) + } +} + +func (s *Flatten_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFlatten_table(s) + } +} + +func (s *Flatten_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFlatten_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Flatten_table() (localctx IFlatten_tableContext) { + localctx = NewFlatten_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 990, SnowflakeParserRULE_flatten_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11402) + p.Match(SnowflakeParserFLATTEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11403) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11406) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1471, p.GetParserRuleContext()) == 1 { + { + p.SetState(11404) + p.Match(SnowflakeParserINPUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11405) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11408) + p.expr(0) + } + p.SetState(11413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11409) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11410) + p.Flatten_table_option() + } + + p.SetState(11415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11416) + p.Match(SnowflakeParserRR_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 +} + +// IPrior_listContext is an interface to support dynamic dispatch. +type IPrior_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPrior_item() []IPrior_itemContext + Prior_item(i int) IPrior_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrior_listContext differentiates from other interfaces. + IsPrior_listContext() +} + +type Prior_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrior_listContext() *Prior_listContext { + var p = new(Prior_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_prior_list + return p +} + +func InitEmptyPrior_listContext(p *Prior_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_prior_list +} + +func (*Prior_listContext) IsPrior_listContext() {} + +func NewPrior_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Prior_listContext { + var p = new(Prior_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_prior_list + + return p +} + +func (s *Prior_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Prior_listContext) AllPrior_item() []IPrior_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrior_itemContext); ok { + len++ + } + } + + tst := make([]IPrior_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrior_itemContext); ok { + tst[i] = t.(IPrior_itemContext) + i++ + } + } + + return tst +} + +func (s *Prior_listContext) Prior_item(i int) IPrior_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrior_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrior_itemContext) +} + +func (s *Prior_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Prior_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Prior_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Prior_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Prior_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPrior_list(s) + } +} + +func (s *Prior_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPrior_list(s) + } +} + +func (s *Prior_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPrior_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Prior_list() (localctx IPrior_listContext) { + localctx = NewPrior_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 992, SnowflakeParserRULE_prior_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11418) + p.Prior_item() + } + p.SetState(11423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1473, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11419) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11420) + p.Prior_item() + } + + } + p.SetState(11425) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1473, 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 +} + +// IPrior_itemContext is an interface to support dynamic dispatch. +type IPrior_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_() []IId_Context + Id_(i int) IId_Context + EQ() antlr.TerminalNode + AllPRIOR() []antlr.TerminalNode + PRIOR(i int) antlr.TerminalNode + + // IsPrior_itemContext differentiates from other interfaces. + IsPrior_itemContext() +} + +type Prior_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrior_itemContext() *Prior_itemContext { + var p = new(Prior_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_prior_item + return p +} + +func InitEmptyPrior_itemContext(p *Prior_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_prior_item +} + +func (*Prior_itemContext) IsPrior_itemContext() {} + +func NewPrior_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Prior_itemContext { + var p = new(Prior_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_prior_item + + return p +} + +func (s *Prior_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Prior_itemContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Prior_itemContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Prior_itemContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Prior_itemContext) AllPRIOR() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserPRIOR) +} + +func (s *Prior_itemContext) PRIOR(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIOR, i) +} + +func (s *Prior_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Prior_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Prior_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPrior_item(s) + } +} + +func (s *Prior_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPrior_item(s) + } +} + +func (s *Prior_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPrior_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Prior_item() (localctx IPrior_itemContext) { + localctx = NewPrior_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 994, SnowflakeParserRULE_prior_item) + p.EnterOuterAlt(localctx, 1) + p.SetState(11427) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1474, p.GetParserRuleContext()) == 1 { + { + p.SetState(11426) + p.Match(SnowflakeParserPRIOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11429) + p.Id_() + } + { + p.SetState(11430) + p.Match(SnowflakeParserEQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11432) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1475, p.GetParserRuleContext()) == 1 { + { + p.SetState(11431) + p.Match(SnowflakeParserPRIOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11434) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOuter_joinContext is an interface to support dynamic dispatch. +type IOuter_joinContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + FULL() antlr.TerminalNode + OUTER() antlr.TerminalNode + + // IsOuter_joinContext differentiates from other interfaces. + IsOuter_joinContext() +} + +type Outer_joinContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOuter_joinContext() *Outer_joinContext { + var p = new(Outer_joinContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_outer_join + return p +} + +func InitEmptyOuter_joinContext(p *Outer_joinContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_outer_join +} + +func (*Outer_joinContext) IsOuter_joinContext() {} + +func NewOuter_joinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Outer_joinContext { + var p = new(Outer_joinContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_outer_join + + return p +} + +func (s *Outer_joinContext) GetParser() antlr.Parser { return s.parser } + +func (s *Outer_joinContext) LEFT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLEFT, 0) +} + +func (s *Outer_joinContext) RIGHT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRIGHT, 0) +} + +func (s *Outer_joinContext) FULL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFULL, 0) +} + +func (s *Outer_joinContext) OUTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOUTER, 0) +} + +func (s *Outer_joinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Outer_joinContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Outer_joinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterOuter_join(s) + } +} + +func (s *Outer_joinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitOuter_join(s) + } +} + +func (s *Outer_joinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitOuter_join(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Outer_join() (localctx IOuter_joinContext) { + localctx = NewOuter_joinContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 996, SnowflakeParserRULE_outer_join) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11436) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserFULL || _la == SnowflakeParserLEFT || _la == SnowflakeParserRIGHT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOUTER { + { + p.SetState(11437) + p.Match(SnowflakeParserOUTER) + 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_typeContext is an interface to support dynamic dispatch. +type IJoin_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INNER() antlr.TerminalNode + Outer_join() IOuter_joinContext + + // 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 = SnowflakeParserRULE_join_type + return p +} + +func InitEmptyJoin_typeContext(p *Join_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_join_type + + return p +} + +func (s *Join_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_typeContext) INNER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINNER, 0) +} + +func (s *Join_typeContext) Outer_join() IOuter_joinContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_joinContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_joinContext) +} + +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.(SnowflakeParserListener); ok { + listenerT.EnterJoin_type(s) + } +} + +func (s *Join_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitJoin_type(s) + } +} + +func (s *Join_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitJoin_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Join_type() (localctx IJoin_typeContext) { + localctx = NewJoin_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 998, SnowflakeParserRULE_join_type) + p.SetState(11442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserINNER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11440) + p.Match(SnowflakeParserINNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserFULL, SnowflakeParserLEFT, SnowflakeParserRIGHT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11441) + p.Outer_join() + } + + 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 +} + +// IJoin_clauseContext is an interface to support dynamic dispatch. +type IJoin_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JOIN() antlr.TerminalNode + Object_ref() IObject_refContext + Join_type() IJoin_typeContext + ON() antlr.TerminalNode + Search_condition() ISearch_conditionContext + USING() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Column_list() IColumn_listContext + RR_BRACKET() antlr.TerminalNode + NATURAL() antlr.TerminalNode + Outer_join() IOuter_joinContext + CROSS() antlr.TerminalNode + + // IsJoin_clauseContext differentiates from other interfaces. + IsJoin_clauseContext() +} + +type Join_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_clauseContext() *Join_clauseContext { + var p = new(Join_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_join_clause + return p +} + +func InitEmptyJoin_clauseContext(p *Join_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_join_clause +} + +func (*Join_clauseContext) IsJoin_clauseContext() {} + +func NewJoin_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_clauseContext { + var p = new(Join_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_join_clause + + return p +} + +func (s *Join_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_clauseContext) JOIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJOIN, 0) +} + +func (s *Join_clauseContext) Object_ref() IObject_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_refContext) +} + +func (s *Join_clauseContext) Join_type() IJoin_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_typeContext) +} + +func (s *Join_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON, 0) +} + +func (s *Join_clauseContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Join_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSING, 0) +} + +func (s *Join_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Join_clauseContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Join_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Join_clauseContext) NATURAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNATURAL, 0) +} + +func (s *Join_clauseContext) Outer_join() IOuter_joinContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_joinContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_joinContext) +} + +func (s *Join_clauseContext) CROSS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCROSS, 0) +} + +func (s *Join_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterJoin_clause(s) + } +} + +func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitJoin_clause(s) + } +} + +func (s *Join_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitJoin_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Join_clause() (localctx IJoin_clauseContext) { + localctx = NewJoin_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1000, SnowflakeParserRULE_join_clause) + var _la int + + p.SetState(11471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserFULL, SnowflakeParserINNER, SnowflakeParserJOIN, SnowflakeParserLEFT, SnowflakeParserRIGHT: + p.EnterOuterAlt(localctx, 1) + p.SetState(11445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFULL || _la == SnowflakeParserINNER || _la == SnowflakeParserLEFT || _la == SnowflakeParserRIGHT { + { + p.SetState(11444) + p.Join_type() + } + + } + { + p.SetState(11447) + p.Match(SnowflakeParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11448) + p.Object_ref() + } + p.SetState(11460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1481, p.GetParserRuleContext()) { + case 1: + p.SetState(11451) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1479, p.GetParserRuleContext()) == 1 { + { + p.SetState(11449) + p.Match(SnowflakeParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11450) + p.search_condition(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(11458) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1480, p.GetParserRuleContext()) == 1 { + { + p.SetState(11453) + p.Match(SnowflakeParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11454) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11455) + p.Column_list() + } + { + p.SetState(11456) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case SnowflakeParserNATURAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11462) + p.Match(SnowflakeParserNATURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFULL || _la == SnowflakeParserLEFT || _la == SnowflakeParserRIGHT { + { + p.SetState(11463) + p.Outer_join() + } + + } + { + p.SetState(11466) + p.Match(SnowflakeParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11467) + p.Object_ref() + } + + case SnowflakeParserCROSS: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11468) + p.Match(SnowflakeParserCROSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11469) + p.Match(SnowflakeParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11470) + p.Object_ref() + } + + 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 +} + +// IAt_beforeContext is an interface to support dynamic dispatch. +type IAt_beforeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AT_KEYWORD() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + ASSOC() antlr.TerminalNode + Expr() IExprContext + OFFSET() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + String_() IStringContext + STREAM() antlr.TerminalNode + BEFORE() antlr.TerminalNode + + // IsAt_beforeContext differentiates from other interfaces. + IsAt_beforeContext() +} + +type At_beforeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAt_beforeContext() *At_beforeContext { + var p = new(At_beforeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_at_before + return p +} + +func InitEmptyAt_beforeContext(p *At_beforeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_at_before +} + +func (*At_beforeContext) IsAt_beforeContext() {} + +func NewAt_beforeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *At_beforeContext { + var p = new(At_beforeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_at_before + + return p +} + +func (s *At_beforeContext) GetParser() antlr.Parser { return s.parser } + +func (s *At_beforeContext) AT_KEYWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAT_KEYWORD, 0) +} + +func (s *At_beforeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *At_beforeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *At_beforeContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP, 0) +} + +func (s *At_beforeContext) ASSOC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASSOC, 0) +} + +func (s *At_beforeContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *At_beforeContext) OFFSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFFSET, 0) +} + +func (s *At_beforeContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT, 0) +} + +func (s *At_beforeContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *At_beforeContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *At_beforeContext) BEFORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBEFORE, 0) +} + +func (s *At_beforeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *At_beforeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *At_beforeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAt_before(s) + } +} + +func (s *At_beforeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAt_before(s) + } +} + +func (s *At_beforeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAt_before(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) At_before() (localctx IAt_beforeContext) { + localctx = NewAt_beforeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1002, SnowflakeParserRULE_at_before) + p.SetState(11498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserAT_KEYWORD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11473) + p.Match(SnowflakeParserAT_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11474) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserTIMESTAMP: + { + p.SetState(11475) + p.Match(SnowflakeParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11476) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11477) + p.expr(0) + } + + case SnowflakeParserOFFSET: + { + p.SetState(11478) + p.Match(SnowflakeParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11479) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11480) + p.expr(0) + } + + case SnowflakeParserSTATEMENT: + { + p.SetState(11481) + p.Match(SnowflakeParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11482) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11483) + p.String_() + } + + case SnowflakeParserSTREAM: + { + p.SetState(11484) + p.Match(SnowflakeParserSTREAM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11485) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11486) + p.String_() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11489) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserBEFORE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11491) + p.Match(SnowflakeParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11492) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11493) + p.Match(SnowflakeParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11494) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11495) + p.String_() + } + { + p.SetState(11496) + p.Match(SnowflakeParserRR_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 +} + +// IEndContext is an interface to support dynamic dispatch. +type IEndContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + END() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + ARROW() antlr.TerminalNode + String_() IStringContext + OFFSET() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + Id_() IId_Context + RR_BRACKET() antlr.TerminalNode + + // IsEndContext differentiates from other interfaces. + IsEndContext() +} + +type EndContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEndContext() *EndContext { + var p = new(EndContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_end + return p +} + +func InitEmptyEndContext(p *EndContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_end +} + +func (*EndContext) IsEndContext() {} + +func NewEndContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EndContext { + var p = new(EndContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_end + + return p +} + +func (s *EndContext) GetParser() antlr.Parser { return s.parser } + +func (s *EndContext) END() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEND, 0) +} + +func (s *EndContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *EndContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP, 0) +} + +func (s *EndContext) ARROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARROW, 0) +} + +func (s *EndContext) String_() IStringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStringContext) +} + +func (s *EndContext) OFFSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFFSET, 0) +} + +func (s *EndContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT, 0) +} + +func (s *EndContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *EndContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *EndContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *EndContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *EndContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterEnd(s) + } +} + +func (s *EndContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitEnd(s) + } +} + +func (s *EndContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitEnd(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) End() (localctx IEndContext) { + localctx = NewEndContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1004, SnowflakeParserRULE_end) + p.SetState(11513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserEND: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11500) + p.Match(SnowflakeParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11501) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11502) + p.Match(SnowflakeParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11503) + p.Match(SnowflakeParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11504) + p.String_() + } + + case SnowflakeParserOFFSET: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11505) + p.Match(SnowflakeParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11506) + p.Match(SnowflakeParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11507) + p.String_() + } + + case SnowflakeParserSTATEMENT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11508) + p.Match(SnowflakeParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11509) + p.Match(SnowflakeParserARROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11510) + p.Id_() + } + { + p.SetState(11511) + p.Match(SnowflakeParserRR_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 +} + +// IChangesContext is an interface to support dynamic dispatch. +type IChangesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHANGES() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + INFORMATION() antlr.TerminalNode + ASSOC() antlr.TerminalNode + Default_append_only() IDefault_append_onlyContext + RR_BRACKET() antlr.TerminalNode + At_before() IAt_beforeContext + End() IEndContext + + // IsChangesContext differentiates from other interfaces. + IsChangesContext() +} + +type ChangesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChangesContext() *ChangesContext { + var p = new(ChangesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_changes + return p +} + +func InitEmptyChangesContext(p *ChangesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_changes +} + +func (*ChangesContext) IsChangesContext() {} + +func NewChangesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ChangesContext { + var p = new(ChangesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_changes + + return p +} + +func (s *ChangesContext) GetParser() antlr.Parser { return s.parser } + +func (s *ChangesContext) CHANGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHANGES, 0) +} + +func (s *ChangesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *ChangesContext) INFORMATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINFORMATION, 0) +} + +func (s *ChangesContext) ASSOC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASSOC, 0) +} + +func (s *ChangesContext) Default_append_only() IDefault_append_onlyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_append_onlyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_append_onlyContext) +} + +func (s *ChangesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *ChangesContext) At_before() IAt_beforeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAt_beforeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAt_beforeContext) +} + +func (s *ChangesContext) End() IEndContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEndContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEndContext) +} + +func (s *ChangesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ChangesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ChangesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterChanges(s) + } +} + +func (s *ChangesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitChanges(s) + } +} + +func (s *ChangesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitChanges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Changes() (localctx IChangesContext) { + localctx = NewChangesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1006, SnowflakeParserRULE_changes) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11515) + p.Match(SnowflakeParserCHANGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11516) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11517) + p.Match(SnowflakeParserINFORMATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11518) + p.Match(SnowflakeParserASSOC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11519) + p.Default_append_only() + } + { + p.SetState(11520) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11521) + p.At_before() + } + p.SetState(11523) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1487, p.GetParserRuleContext()) == 1 { + { + p.SetState(11522) + p.End() + } + + } 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 +} + +// IDefault_append_onlyContext is an interface to support dynamic dispatch. +type IDefault_append_onlyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + APPEND() antlr.TerminalNode + ONLY() antlr.TerminalNode + + // IsDefault_append_onlyContext differentiates from other interfaces. + IsDefault_append_onlyContext() +} + +type Default_append_onlyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_append_onlyContext() *Default_append_onlyContext { + var p = new(Default_append_onlyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_default_append_only + return p +} + +func InitEmptyDefault_append_onlyContext(p *Default_append_onlyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_default_append_only +} + +func (*Default_append_onlyContext) IsDefault_append_onlyContext() {} + +func NewDefault_append_onlyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_append_onlyContext { + var p = new(Default_append_onlyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_default_append_only + + return p +} + +func (s *Default_append_onlyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_append_onlyContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT, 0) +} + +func (s *Default_append_onlyContext) APPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPPEND, 0) +} + +func (s *Default_append_onlyContext) ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserONLY, 0) +} + +func (s *Default_append_onlyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_append_onlyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_append_onlyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDefault_append_only(s) + } +} + +func (s *Default_append_onlyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDefault_append_only(s) + } +} + +func (s *Default_append_onlyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDefault_append_only(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Default_append_only() (localctx IDefault_append_onlyContext) { + localctx = NewDefault_append_onlyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1008, SnowflakeParserRULE_default_append_only) + p.SetState(11528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserDEFAULT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11525) + p.Match(SnowflakeParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserAPPEND: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11526) + p.Match(SnowflakeParserAPPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11527) + p.Match(SnowflakeParserONLY) + 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 +} + +// IPartition_byContext is an interface to support dynamic dispatch. +type IPartition_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Expr_list() IExpr_listContext + + // IsPartition_byContext differentiates from other interfaces. + IsPartition_byContext() +} + +type Partition_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_byContext() *Partition_byContext { + var p = new(Partition_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_partition_by + return p +} + +func InitEmptyPartition_byContext(p *Partition_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_partition_by +} + +func (*Partition_byContext) IsPartition_byContext() {} + +func NewPartition_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_byContext { + var p = new(Partition_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_partition_by + + return p +} + +func (s *Partition_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_byContext) PARTITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARTITION, 0) +} + +func (s *Partition_byContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Partition_byContext) 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 *Partition_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPartition_by(s) + } +} + +func (s *Partition_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPartition_by(s) + } +} + +func (s *Partition_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPartition_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Partition_by() (localctx IPartition_byContext) { + localctx = NewPartition_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1010, SnowflakeParserRULE_partition_by) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11530) + p.Match(SnowflakeParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11531) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11532) + 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 +} + +// IAliasContext is an interface to support dynamic dispatch. +type IAliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + + // IsAliasContext differentiates from other interfaces. + IsAliasContext() +} + +type AliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAliasContext() *AliasContext { + var p = new(AliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alias + return p +} + +func InitEmptyAliasContext(p *AliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_alias +} + +func (*AliasContext) IsAliasContext() {} + +func NewAliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AliasContext { + var p = new(AliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_alias + + return p +} + +func (s *AliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *AliasContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *AliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAlias(s) + } +} + +func (s *AliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAlias(s) + } +} + +func (s *AliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAlias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Alias() (localctx IAliasContext) { + localctx = NewAliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1012, SnowflakeParserRULE_alias) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11534) + p.Id_() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_alias_listContext is an interface to support dynamic dispatch. +type IExpr_alias_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpr() []IExprContext + Expr(i int) IExprContext + AllAlias() []IAliasContext + Alias(i int) IAliasContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExpr_alias_listContext differentiates from other interfaces. + IsExpr_alias_listContext() +} + +type Expr_alias_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpr_alias_listContext() *Expr_alias_listContext { + var p = new(Expr_alias_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expr_alias_list + return p +} + +func InitEmptyExpr_alias_listContext(p *Expr_alias_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expr_alias_list +} + +func (*Expr_alias_listContext) IsExpr_alias_listContext() {} + +func NewExpr_alias_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_alias_listContext { + var p = new(Expr_alias_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_expr_alias_list + + return p +} + +func (s *Expr_alias_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_alias_listContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Expr_alias_listContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Expr_alias_listContext) AllAlias() []IAliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAliasContext); ok { + len++ + } + } + + tst := make([]IAliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAliasContext); ok { + tst[i] = t.(IAliasContext) + i++ + } + } + + return tst +} + +func (s *Expr_alias_listContext) Alias(i int) IAliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAliasContext) +} + +func (s *Expr_alias_listContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserAS) +} + +func (s *Expr_alias_listContext) AS(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, i) +} + +func (s *Expr_alias_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Expr_alias_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Expr_alias_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expr_alias_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expr_alias_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExpr_alias_list(s) + } +} + +func (s *Expr_alias_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExpr_alias_list(s) + } +} + +func (s *Expr_alias_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExpr_alias_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Expr_alias_list() (localctx IExpr_alias_listContext) { + localctx = NewExpr_alias_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1014, SnowflakeParserRULE_expr_alias_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11536) + p.expr(0) + } + p.SetState(11538) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAS { + { + p.SetState(11537) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11540) + p.Alias() + } + p.SetState(11550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11541) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11542) + p.expr(0) + } + p.SetState(11544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAS { + { + p.SetState(11543) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11546) + p.Alias() + } + + p.SetState(11552) + 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 +} + +// IMeasuresContext is an interface to support dynamic dispatch. +type IMeasuresContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEASURES() antlr.TerminalNode + Expr_alias_list() IExpr_alias_listContext + + // IsMeasuresContext differentiates from other interfaces. + IsMeasuresContext() +} + +type MeasuresContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMeasuresContext() *MeasuresContext { + var p = new(MeasuresContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_measures + return p +} + +func InitEmptyMeasuresContext(p *MeasuresContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_measures +} + +func (*MeasuresContext) IsMeasuresContext() {} + +func NewMeasuresContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MeasuresContext { + var p = new(MeasuresContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_measures + + return p +} + +func (s *MeasuresContext) GetParser() antlr.Parser { return s.parser } + +func (s *MeasuresContext) MEASURES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMEASURES, 0) +} + +func (s *MeasuresContext) Expr_alias_list() IExpr_alias_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_alias_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpr_alias_listContext) +} + +func (s *MeasuresContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MeasuresContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MeasuresContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterMeasures(s) + } +} + +func (s *MeasuresContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitMeasures(s) + } +} + +func (s *MeasuresContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitMeasures(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Measures() (localctx IMeasuresContext) { + localctx = NewMeasuresContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1016, SnowflakeParserRULE_measures) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11553) + p.Match(SnowflakeParserMEASURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11554) + p.Expr_alias_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 +} + +// IMatch_optsContext is an interface to support dynamic dispatch. +type IMatch_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHOW() antlr.TerminalNode + EMPTY_() antlr.TerminalNode + MATCHES() antlr.TerminalNode + OMIT() antlr.TerminalNode + WITH() antlr.TerminalNode + UNMATCHED() antlr.TerminalNode + ROWS() antlr.TerminalNode + + // IsMatch_optsContext differentiates from other interfaces. + IsMatch_optsContext() +} + +type Match_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMatch_optsContext() *Match_optsContext { + var p = new(Match_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_match_opts + return p +} + +func InitEmptyMatch_optsContext(p *Match_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_match_opts +} + +func (*Match_optsContext) IsMatch_optsContext() {} + +func NewMatch_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Match_optsContext { + var p = new(Match_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_match_opts + + return p +} + +func (s *Match_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Match_optsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Match_optsContext) EMPTY_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEMPTY_, 0) +} + +func (s *Match_optsContext) MATCHES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCHES, 0) +} + +func (s *Match_optsContext) OMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOMIT, 0) +} + +func (s *Match_optsContext) WITH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITH, 0) +} + +func (s *Match_optsContext) UNMATCHED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNMATCHED, 0) +} + +func (s *Match_optsContext) ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWS, 0) +} + +func (s *Match_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Match_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Match_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterMatch_opts(s) + } +} + +func (s *Match_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitMatch_opts(s) + } +} + +func (s *Match_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitMatch_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Match_opts() (localctx IMatch_optsContext) { + localctx = NewMatch_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1018, SnowflakeParserRULE_match_opts) + p.SetState(11565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserSHOW: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11556) + p.Match(SnowflakeParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11557) + p.Match(SnowflakeParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11558) + p.Match(SnowflakeParserMATCHES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserOMIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11559) + p.Match(SnowflakeParserOMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11560) + p.Match(SnowflakeParserEMPTY_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11561) + p.Match(SnowflakeParserMATCHES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserWITH: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11562) + p.Match(SnowflakeParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11563) + p.Match(SnowflakeParserUNMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11564) + p.Match(SnowflakeParserROWS) + 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 +} + +// IRow_matchContext is an interface to support dynamic dispatch. +type IRow_matchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ONE() antlr.TerminalNode + ROW() antlr.TerminalNode + PER() antlr.TerminalNode + MATCH() antlr.TerminalNode + ALL() antlr.TerminalNode + ROWS() antlr.TerminalNode + Match_opts() IMatch_optsContext + + // IsRow_matchContext differentiates from other interfaces. + IsRow_matchContext() +} + +type Row_matchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_matchContext() *Row_matchContext { + var p = new(Row_matchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_row_match + return p +} + +func InitEmptyRow_matchContext(p *Row_matchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_row_match +} + +func (*Row_matchContext) IsRow_matchContext() {} + +func NewRow_matchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_matchContext { + var p = new(Row_matchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_row_match + + return p +} + +func (s *Row_matchContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_matchContext) ONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserONE, 0) +} + +func (s *Row_matchContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Row_matchContext) PER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPER, 0) +} + +func (s *Row_matchContext) MATCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCH, 0) +} + +func (s *Row_matchContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *Row_matchContext) ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWS, 0) +} + +func (s *Row_matchContext) Match_opts() IMatch_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMatch_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMatch_optsContext) +} + +func (s *Row_matchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_matchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_matchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRow_match(s) + } +} + +func (s *Row_matchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRow_match(s) + } +} + +func (s *Row_matchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRow_match(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Row_match() (localctx IRow_matchContext) { + localctx = NewRow_matchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1020, SnowflakeParserRULE_row_match) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserONE: + { + p.SetState(11567) + p.Match(SnowflakeParserONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11568) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11569) + p.Match(SnowflakeParserPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11570) + p.Match(SnowflakeParserMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserALL: + { + p.SetState(11571) + p.Match(SnowflakeParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11572) + p.Match(SnowflakeParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11573) + p.Match(SnowflakeParserPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11574) + p.Match(SnowflakeParserMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOMIT || _la == SnowflakeParserSHOW || _la == SnowflakeParserWITH { + { + p.SetState(11577) + p.Match_opts() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_lastContext is an interface to support dynamic dispatch. +type IFirst_lastContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + + // IsFirst_lastContext differentiates from other interfaces. + IsFirst_lastContext() +} + +type First_lastContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFirst_lastContext() *First_lastContext { + var p = new(First_lastContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_first_last + return p +} + +func InitEmptyFirst_lastContext(p *First_lastContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_first_last +} + +func (*First_lastContext) IsFirst_lastContext() {} + +func NewFirst_lastContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *First_lastContext { + var p = new(First_lastContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_first_last + + return p +} + +func (s *First_lastContext) GetParser() antlr.Parser { return s.parser } + +func (s *First_lastContext) FIRST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIRST, 0) +} + +func (s *First_lastContext) LAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST, 0) +} + +func (s *First_lastContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *First_lastContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *First_lastContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFirst_last(s) + } +} + +func (s *First_lastContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFirst_last(s) + } +} + +func (s *First_lastContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFirst_last(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) First_last() (localctx IFirst_lastContext) { + localctx = NewFirst_lastContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1022, SnowflakeParserRULE_first_last) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11580) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserFIRST || _la == SnowflakeParserLAST) { + 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 +} + +// ISymbolContext is an interface to support dynamic dispatch. +type ISymbolContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DUMMY() antlr.TerminalNode + + // IsSymbolContext differentiates from other interfaces. + IsSymbolContext() +} + +type SymbolContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySymbolContext() *SymbolContext { + var p = new(SymbolContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_symbol + return p +} + +func InitEmptySymbolContext(p *SymbolContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_symbol +} + +func (*SymbolContext) IsSymbolContext() {} + +func NewSymbolContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SymbolContext { + var p = new(SymbolContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_symbol + + return p +} + +func (s *SymbolContext) GetParser() antlr.Parser { return s.parser } + +func (s *SymbolContext) DUMMY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDUMMY, 0) +} + +func (s *SymbolContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SymbolContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SymbolContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSymbol(s) + } +} + +func (s *SymbolContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSymbol(s) + } +} + +func (s *SymbolContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSymbol(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Symbol() (localctx ISymbolContext) { + localctx = NewSymbolContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1024, SnowflakeParserRULE_symbol) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11582) + p.Match(SnowflakeParserDUMMY) + 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 +} + +// IAfter_matchContext is an interface to support dynamic dispatch. +type IAfter_matchContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AFTER() antlr.TerminalNode + MATCH() antlr.TerminalNode + SKIP_() antlr.TerminalNode + PAST() antlr.TerminalNode + LAST() antlr.TerminalNode + ROW() antlr.TerminalNode + TO() antlr.TerminalNode + NEXT() antlr.TerminalNode + Symbol() ISymbolContext + First_last() IFirst_lastContext + + // IsAfter_matchContext differentiates from other interfaces. + IsAfter_matchContext() +} + +type After_matchContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAfter_matchContext() *After_matchContext { + var p = new(After_matchContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_after_match + return p +} + +func InitEmptyAfter_matchContext(p *After_matchContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_after_match +} + +func (*After_matchContext) IsAfter_matchContext() {} + +func NewAfter_matchContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *After_matchContext { + var p = new(After_matchContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_after_match + + return p +} + +func (s *After_matchContext) GetParser() antlr.Parser { return s.parser } + +func (s *After_matchContext) AFTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAFTER, 0) +} + +func (s *After_matchContext) MATCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCH, 0) +} + +func (s *After_matchContext) SKIP_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_, 0) +} + +func (s *After_matchContext) PAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPAST, 0) +} + +func (s *After_matchContext) LAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST, 0) +} + +func (s *After_matchContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *After_matchContext) TO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO, 0) +} + +func (s *After_matchContext) NEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEXT, 0) +} + +func (s *After_matchContext) Symbol() ISymbolContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISymbolContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISymbolContext) +} + +func (s *After_matchContext) First_last() IFirst_lastContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFirst_lastContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFirst_lastContext) +} + +func (s *After_matchContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *After_matchContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *After_matchContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterAfter_match(s) + } +} + +func (s *After_matchContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitAfter_match(s) + } +} + +func (s *After_matchContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitAfter_match(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) After_match() (localctx IAfter_matchContext) { + localctx = NewAfter_matchContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1026, SnowflakeParserRULE_after_match) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11584) + p.Match(SnowflakeParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11585) + p.Match(SnowflakeParserMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11586) + p.Match(SnowflakeParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1496, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11587) + p.Match(SnowflakeParserPAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11588) + p.Match(SnowflakeParserLAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11589) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(11590) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11591) + p.Match(SnowflakeParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11592) + p.Match(SnowflakeParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(11593) + p.Match(SnowflakeParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFIRST || _la == SnowflakeParserLAST { + { + p.SetState(11594) + p.First_last() + } + + } + { + p.SetState(11597) + p.Symbol() + } + + 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 +} + +// ISymbol_listContext is an interface to support dynamic dispatch. +type ISymbol_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSymbol() []ISymbolContext + Symbol(i int) ISymbolContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSymbol_listContext differentiates from other interfaces. + IsSymbol_listContext() +} + +type Symbol_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySymbol_listContext() *Symbol_listContext { + var p = new(Symbol_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_symbol_list + return p +} + +func InitEmptySymbol_listContext(p *Symbol_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_symbol_list +} + +func (*Symbol_listContext) IsSymbol_listContext() {} + +func NewSymbol_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Symbol_listContext { + var p = new(Symbol_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_symbol_list + + return p +} + +func (s *Symbol_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Symbol_listContext) AllSymbol() []ISymbolContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISymbolContext); ok { + len++ + } + } + + tst := make([]ISymbolContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISymbolContext); ok { + tst[i] = t.(ISymbolContext) + i++ + } + } + + return tst +} + +func (s *Symbol_listContext) Symbol(i int) ISymbolContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISymbolContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISymbolContext) +} + +func (s *Symbol_listContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserAS) +} + +func (s *Symbol_listContext) AS(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserAS, i) +} + +func (s *Symbol_listContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *Symbol_listContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Symbol_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Symbol_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Symbol_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Symbol_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Symbol_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSymbol_list(s) + } +} + +func (s *Symbol_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSymbol_list(s) + } +} + +func (s *Symbol_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSymbol_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Symbol_list() (localctx ISymbol_listContext) { + localctx = NewSymbol_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1028, SnowflakeParserRULE_symbol_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11600) + p.Symbol() + } + { + p.SetState(11601) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11602) + p.expr(0) + } + p.SetState(11610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11603) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11604) + p.Symbol() + } + { + p.SetState(11605) + p.Match(SnowflakeParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11606) + p.expr(0) + } + + p.SetState(11612) + 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 +} + +// IDefineContext is an interface to support dynamic dispatch. +type IDefineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFINE() antlr.TerminalNode + Symbol_list() ISymbol_listContext + + // IsDefineContext differentiates from other interfaces. + IsDefineContext() +} + +type DefineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefineContext() *DefineContext { + var p = new(DefineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_define + return p +} + +func InitEmptyDefineContext(p *DefineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_define +} + +func (*DefineContext) IsDefineContext() {} + +func NewDefineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefineContext { + var p = new(DefineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_define + + return p +} + +func (s *DefineContext) GetParser() antlr.Parser { return s.parser } + +func (s *DefineContext) DEFINE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFINE, 0) +} + +func (s *DefineContext) Symbol_list() ISymbol_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISymbol_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISymbol_listContext) +} + +func (s *DefineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DefineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DefineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterDefine(s) + } +} + +func (s *DefineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitDefine(s) + } +} + +func (s *DefineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitDefine(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Define() (localctx IDefineContext) { + localctx = NewDefineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1030, SnowflakeParserRULE_define) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11613) + p.Match(SnowflakeParserDEFINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11614) + p.Symbol_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 +} + +// IMatch_recognizeContext is an interface to support dynamic dispatch. +type IMatch_recognizeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MATCH_RECOGNIZE() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Partition_by() IPartition_byContext + Order_by_clause() IOrder_by_clauseContext + Measures() IMeasuresContext + Row_match() IRow_matchContext + After_match() IAfter_matchContext + Pattern() IPatternContext + Define() IDefineContext + + // IsMatch_recognizeContext differentiates from other interfaces. + IsMatch_recognizeContext() +} + +type Match_recognizeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMatch_recognizeContext() *Match_recognizeContext { + var p = new(Match_recognizeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_match_recognize + return p +} + +func InitEmptyMatch_recognizeContext(p *Match_recognizeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_match_recognize +} + +func (*Match_recognizeContext) IsMatch_recognizeContext() {} + +func NewMatch_recognizeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Match_recognizeContext { + var p = new(Match_recognizeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_match_recognize + + return p +} + +func (s *Match_recognizeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Match_recognizeContext) MATCH_RECOGNIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCH_RECOGNIZE, 0) +} + +func (s *Match_recognizeContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Match_recognizeContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Match_recognizeContext) Partition_by() IPartition_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_byContext) +} + +func (s *Match_recognizeContext) Order_by_clause() IOrder_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Match_recognizeContext) Measures() IMeasuresContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeasuresContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeasuresContext) +} + +func (s *Match_recognizeContext) Row_match() IRow_matchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_matchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_matchContext) +} + +func (s *Match_recognizeContext) After_match() IAfter_matchContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAfter_matchContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAfter_matchContext) +} + +func (s *Match_recognizeContext) Pattern() IPatternContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPatternContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPatternContext) +} + +func (s *Match_recognizeContext) Define() IDefineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefineContext) +} + +func (s *Match_recognizeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Match_recognizeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Match_recognizeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterMatch_recognize(s) + } +} + +func (s *Match_recognizeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitMatch_recognize(s) + } +} + +func (s *Match_recognizeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitMatch_recognize(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Match_recognize() (localctx IMatch_recognizeContext) { + localctx = NewMatch_recognizeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1032, SnowflakeParserRULE_match_recognize) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11616) + p.Match(SnowflakeParserMATCH_RECOGNIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11617) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPARTITION { + { + p.SetState(11618) + p.Partition_by() + } + + } + p.SetState(11622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserORDER { + { + p.SetState(11621) + p.Order_by_clause() + } + + } + p.SetState(11625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserMEASURES { + { + p.SetState(11624) + p.Measures() + } + + } + p.SetState(11628) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserALL || _la == SnowflakeParserONE { + { + p.SetState(11627) + p.Row_match() + } + + } + p.SetState(11631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserAFTER { + { + p.SetState(11630) + p.After_match() + } + + } + p.SetState(11634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserPATTERN { + { + p.SetState(11633) + p.Pattern() + } + + } + p.SetState(11637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserDEFINE { + { + p.SetState(11636) + p.Define() + } + + } + { + p.SetState(11639) + p.Match(SnowflakeParserRR_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 +} + +// IPivot_unpivotContext is an interface to support dynamic dispatch. +type IPivot_unpivotContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PIVOT() antlr.TerminalNode + AllLR_BRACKET() []antlr.TerminalNode + LR_BRACKET(i int) antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + AllRR_BRACKET() []antlr.TerminalNode + RR_BRACKET(i int) antlr.TerminalNode + FOR() antlr.TerminalNode + IN() antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + UNPIVOT() antlr.TerminalNode + Column_name() IColumn_nameContext + Column_list() IColumn_listContext + + // IsPivot_unpivotContext differentiates from other interfaces. + IsPivot_unpivotContext() +} + +type Pivot_unpivotContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_unpivotContext() *Pivot_unpivotContext { + var p = new(Pivot_unpivotContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_pivot_unpivot + return p +} + +func InitEmptyPivot_unpivotContext(p *Pivot_unpivotContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_pivot_unpivot +} + +func (*Pivot_unpivotContext) IsPivot_unpivotContext() {} + +func NewPivot_unpivotContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_unpivotContext { + var p = new(Pivot_unpivotContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_pivot_unpivot + + return p +} + +func (s *Pivot_unpivotContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_unpivotContext) PIVOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIVOT, 0) +} + +func (s *Pivot_unpivotContext) AllLR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserLR_BRACKET) +} + +func (s *Pivot_unpivotContext) LR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, i) +} + +func (s *Pivot_unpivotContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Pivot_unpivotContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Pivot_unpivotContext) AllRR_BRACKET() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserRR_BRACKET) +} + +func (s *Pivot_unpivotContext) RR_BRACKET(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, i) +} + +func (s *Pivot_unpivotContext) FOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFOR, 0) +} + +func (s *Pivot_unpivotContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *Pivot_unpivotContext) AllLiteral() []ILiteralContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILiteralContext); ok { + len++ + } + } + + tst := make([]ILiteralContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILiteralContext); ok { + tst[i] = t.(ILiteralContext) + i++ + } + } + + return tst +} + +func (s *Pivot_unpivotContext) Literal(i int) ILiteralContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILiteralContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILiteralContext) +} + +func (s *Pivot_unpivotContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Pivot_unpivotContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Pivot_unpivotContext) UNPIVOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNPIVOT, 0) +} + +func (s *Pivot_unpivotContext) Column_name() IColumn_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_nameContext) +} + +func (s *Pivot_unpivotContext) Column_list() IColumn_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_listContext) +} + +func (s *Pivot_unpivotContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_unpivotContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_unpivotContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPivot_unpivot(s) + } +} + +func (s *Pivot_unpivotContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPivot_unpivot(s) + } +} + +func (s *Pivot_unpivotContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPivot_unpivot(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Pivot_unpivot() (localctx IPivot_unpivotContext) { + localctx = NewPivot_unpivotContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1034, SnowflakeParserRULE_pivot_unpivot) + var _la int + + p.SetState(11673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserPIVOT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11641) + p.Match(SnowflakeParserPIVOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11642) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11643) + p.Id_() + } + { + p.SetState(11644) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11645) + p.Id_() + } + { + p.SetState(11646) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11647) + p.Match(SnowflakeParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11648) + p.Id_() + } + { + p.SetState(11649) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11650) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11651) + p.Literal() + } + p.SetState(11656) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11652) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11653) + p.Literal() + } + + p.SetState(11658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11659) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11660) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserUNPIVOT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11662) + p.Match(SnowflakeParserUNPIVOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11663) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11664) + p.Id_() + } + { + p.SetState(11665) + p.Match(SnowflakeParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11666) + p.Column_name() + } + { + p.SetState(11667) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11668) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11669) + p.Column_list() + } + { + p.SetState(11670) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11671) + p.Match(SnowflakeParserRR_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 +} + +// IColumn_alias_list_in_bracketsContext is an interface to support dynamic dispatch. +type IColumn_alias_list_in_bracketsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + AllId_() []IId_Context + Id_(i int) IId_Context + RR_BRACKET() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_alias_list_in_bracketsContext differentiates from other interfaces. + IsColumn_alias_list_in_bracketsContext() +} + +type Column_alias_list_in_bracketsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_alias_list_in_bracketsContext() *Column_alias_list_in_bracketsContext { + var p = new(Column_alias_list_in_bracketsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_alias_list_in_brackets + return p +} + +func InitEmptyColumn_alias_list_in_bracketsContext(p *Column_alias_list_in_bracketsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_column_alias_list_in_brackets +} + +func (*Column_alias_list_in_bracketsContext) IsColumn_alias_list_in_bracketsContext() {} + +func NewColumn_alias_list_in_bracketsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_alias_list_in_bracketsContext { + var p = new(Column_alias_list_in_bracketsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_column_alias_list_in_brackets + + return p +} + +func (s *Column_alias_list_in_bracketsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_alias_list_in_bracketsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Column_alias_list_in_bracketsContext) AllId_() []IId_Context { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_Context); ok { + len++ + } + } + + tst := make([]IId_Context, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_Context); ok { + tst[i] = t.(IId_Context) + i++ + } + } + + return tst +} + +func (s *Column_alias_list_in_bracketsContext) Id_(i int) IId_Context { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Column_alias_list_in_bracketsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Column_alias_list_in_bracketsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Column_alias_list_in_bracketsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Column_alias_list_in_bracketsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_alias_list_in_bracketsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_alias_list_in_bracketsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterColumn_alias_list_in_brackets(s) + } +} + +func (s *Column_alias_list_in_bracketsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitColumn_alias_list_in_brackets(s) + } +} + +func (s *Column_alias_list_in_bracketsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitColumn_alias_list_in_brackets(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Column_alias_list_in_brackets() (localctx IColumn_alias_list_in_bracketsContext) { + localctx = NewColumn_alias_list_in_bracketsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1036, SnowflakeParserRULE_column_alias_list_in_brackets) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11675) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11676) + p.Id_() + } + p.SetState(11681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11677) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11678) + p.Id_() + } + + p.SetState(11683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11684) + p.Match(SnowflakeParserRR_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 +} + +// IExpr_list_in_parenthesesContext is an interface to support dynamic dispatch. +type IExpr_list_in_parenthesesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Expr_list() IExpr_listContext + RR_BRACKET() antlr.TerminalNode + + // IsExpr_list_in_parenthesesContext differentiates from other interfaces. + IsExpr_list_in_parenthesesContext() +} + +type Expr_list_in_parenthesesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpr_list_in_parenthesesContext() *Expr_list_in_parenthesesContext { + var p = new(Expr_list_in_parenthesesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expr_list_in_parentheses + return p +} + +func InitEmptyExpr_list_in_parenthesesContext(p *Expr_list_in_parenthesesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_expr_list_in_parentheses +} + +func (*Expr_list_in_parenthesesContext) IsExpr_list_in_parenthesesContext() {} + +func NewExpr_list_in_parenthesesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Expr_list_in_parenthesesContext { + var p = new(Expr_list_in_parenthesesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_expr_list_in_parentheses + + return p +} + +func (s *Expr_list_in_parenthesesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Expr_list_in_parenthesesContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Expr_list_in_parenthesesContext) 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 *Expr_list_in_parenthesesContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Expr_list_in_parenthesesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Expr_list_in_parenthesesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Expr_list_in_parenthesesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterExpr_list_in_parentheses(s) + } +} + +func (s *Expr_list_in_parenthesesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitExpr_list_in_parentheses(s) + } +} + +func (s *Expr_list_in_parenthesesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitExpr_list_in_parentheses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Expr_list_in_parentheses() (localctx IExpr_list_in_parenthesesContext) { + localctx = NewExpr_list_in_parenthesesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1038, SnowflakeParserRULE_expr_list_in_parentheses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11686) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11687) + p.Expr_list() + } + { + p.SetState(11688) + p.Match(SnowflakeParserRR_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 +} + +// IValuesContext is an interface to support dynamic dispatch. +type IValuesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + AllExpr_list_in_parentheses() []IExpr_list_in_parenthesesContext + Expr_list_in_parentheses(i int) IExpr_list_in_parenthesesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + As_alias() IAs_aliasContext + Column_alias_list_in_brackets() IColumn_alias_list_in_bracketsContext + + // IsValuesContext differentiates from other interfaces. + IsValuesContext() +} + +type ValuesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValuesContext() *ValuesContext { + var p = new(ValuesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_values + return p +} + +func InitEmptyValuesContext(p *ValuesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_values +} + +func (*ValuesContext) IsValuesContext() {} + +func NewValuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValuesContext { + var p = new(ValuesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_values + + return p +} + +func (s *ValuesContext) GetParser() antlr.Parser { return s.parser } + +func (s *ValuesContext) VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALUES, 0) +} + +func (s *ValuesContext) AllExpr_list_in_parentheses() []IExpr_list_in_parenthesesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpr_list_in_parenthesesContext); ok { + len++ + } + } + + tst := make([]IExpr_list_in_parenthesesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpr_list_in_parenthesesContext); ok { + tst[i] = t.(IExpr_list_in_parenthesesContext) + i++ + } + } + + return tst +} + +func (s *ValuesContext) Expr_list_in_parentheses(i int) IExpr_list_in_parenthesesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpr_list_in_parenthesesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpr_list_in_parenthesesContext) +} + +func (s *ValuesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *ValuesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *ValuesContext) As_alias() IAs_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAs_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAs_aliasContext) +} + +func (s *ValuesContext) Column_alias_list_in_brackets() IColumn_alias_list_in_bracketsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_alias_list_in_bracketsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_alias_list_in_bracketsContext) +} + +func (s *ValuesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ValuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ValuesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterValues(s) + } +} + +func (s *ValuesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitValues(s) + } +} + +func (s *ValuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitValues(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Values() (localctx IValuesContext) { + localctx = NewValuesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1040, SnowflakeParserRULE_values) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11690) + p.Match(SnowflakeParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11691) + p.Expr_list_in_parentheses() + } + p.SetState(11696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11692) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11693) + p.Expr_list_in_parentheses() + } + + p.SetState(11698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(11700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-10170490946050) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055952707) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&3808706131132401) != 0) { + { + p.SetState(11699) + p.As_alias() + } + + } + p.SetState(11703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserLR_BRACKET { + { + p.SetState(11702) + p.Column_alias_list_in_brackets() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISample_methodContext is an interface to support dynamic dispatch. +type ISample_methodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BERNOULLI() antlr.TerminalNode + ROW() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + BLOCK() antlr.TerminalNode + + // IsSample_methodContext differentiates from other interfaces. + IsSample_methodContext() +} + +type Sample_methodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySample_methodContext() *Sample_methodContext { + var p = new(Sample_methodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sample_method + return p +} + +func InitEmptySample_methodContext(p *Sample_methodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sample_method +} + +func (*Sample_methodContext) IsSample_methodContext() {} + +func NewSample_methodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sample_methodContext { + var p = new(Sample_methodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_sample_method + + return p +} + +func (s *Sample_methodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sample_methodContext) BERNOULLI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBERNOULLI, 0) +} + +func (s *Sample_methodContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Sample_methodContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYSTEM, 0) +} + +func (s *Sample_methodContext) BLOCK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBLOCK, 0) +} + +func (s *Sample_methodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sample_methodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sample_methodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSample_method(s) + } +} + +func (s *Sample_methodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSample_method(s) + } +} + +func (s *Sample_methodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSample_method(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Sample_method() (localctx ISample_methodContext) { + localctx = NewSample_methodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1042, SnowflakeParserRULE_sample_method) + var _la int + + p.SetState(11707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserBERNOULLI, SnowflakeParserROW: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11705) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserBERNOULLI || _la == SnowflakeParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case SnowflakeParserBLOCK, SnowflakeParserSYSTEM: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11706) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserBLOCK || _la == SnowflakeParserSYSTEM) { + 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 +} + +// IRepeatable_seedContext is an interface to support dynamic dispatch. +type IRepeatable_seedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + Num() INumContext + RR_BRACKET() antlr.TerminalNode + REPEATABLE() antlr.TerminalNode + SEED() antlr.TerminalNode + + // IsRepeatable_seedContext differentiates from other interfaces. + IsRepeatable_seedContext() +} + +type Repeatable_seedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRepeatable_seedContext() *Repeatable_seedContext { + var p = new(Repeatable_seedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_repeatable_seed + return p +} + +func InitEmptyRepeatable_seedContext(p *Repeatable_seedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_repeatable_seed +} + +func (*Repeatable_seedContext) IsRepeatable_seedContext() {} + +func NewRepeatable_seedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Repeatable_seedContext { + var p = new(Repeatable_seedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_repeatable_seed + + return p +} + +func (s *Repeatable_seedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Repeatable_seedContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Repeatable_seedContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Repeatable_seedContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Repeatable_seedContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPEATABLE, 0) +} + +func (s *Repeatable_seedContext) SEED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEED, 0) +} + +func (s *Repeatable_seedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Repeatable_seedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Repeatable_seedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRepeatable_seed(s) + } +} + +func (s *Repeatable_seedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRepeatable_seed(s) + } +} + +func (s *Repeatable_seedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRepeatable_seed(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Repeatable_seed() (localctx IRepeatable_seedContext) { + localctx = NewRepeatable_seedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1044, SnowflakeParserRULE_repeatable_seed) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11709) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserREPEATABLE || _la == SnowflakeParserSEED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11710) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11711) + p.Num() + } + { + p.SetState(11712) + p.Match(SnowflakeParserRR_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 +} + +// ISample_optsContext is an interface to support dynamic dispatch. +type ISample_optsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + Num() INumContext + Repeatable_seed() IRepeatable_seedContext + ROWS() antlr.TerminalNode + + // IsSample_optsContext differentiates from other interfaces. + IsSample_optsContext() +} + +type Sample_optsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySample_optsContext() *Sample_optsContext { + var p = new(Sample_optsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sample_opts + return p +} + +func InitEmptySample_optsContext(p *Sample_optsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sample_opts +} + +func (*Sample_optsContext) IsSample_optsContext() {} + +func NewSample_optsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sample_optsContext { + var p = new(Sample_optsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_sample_opts + + return p +} + +func (s *Sample_optsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sample_optsContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Sample_optsContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Sample_optsContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Sample_optsContext) Repeatable_seed() IRepeatable_seedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRepeatable_seedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRepeatable_seedContext) +} + +func (s *Sample_optsContext) ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWS, 0) +} + +func (s *Sample_optsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sample_optsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sample_optsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSample_opts(s) + } +} + +func (s *Sample_optsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSample_opts(s) + } +} + +func (s *Sample_optsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSample_opts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Sample_opts() (localctx ISample_optsContext) { + localctx = NewSample_optsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1046, SnowflakeParserRULE_sample_opts) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11714) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1512, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11715) + p.Num() + } + + case 2: + { + p.SetState(11716) + p.Num() + } + { + p.SetState(11717) + p.Match(SnowflakeParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11721) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11723) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1513, p.GetParserRuleContext()) == 1 { + { + p.SetState(11722) + p.Repeatable_seed() + } + + } 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 +} + +// ISampleContext is an interface to support dynamic dispatch. +type ISampleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Sample_opts() ISample_optsContext + SAMPLE() antlr.TerminalNode + TABLESAMPLE() antlr.TerminalNode + Sample_method() ISample_methodContext + + // IsSampleContext differentiates from other interfaces. + IsSampleContext() +} + +type SampleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySampleContext() *SampleContext { + var p = new(SampleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sample + return p +} + +func InitEmptySampleContext(p *SampleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_sample +} + +func (*SampleContext) IsSampleContext() {} + +func NewSampleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SampleContext { + var p = new(SampleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_sample + + return p +} + +func (s *SampleContext) GetParser() antlr.Parser { return s.parser } + +func (s *SampleContext) Sample_opts() ISample_optsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_optsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_optsContext) +} + +func (s *SampleContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAMPLE, 0) +} + +func (s *SampleContext) TABLESAMPLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLESAMPLE, 0) +} + +func (s *SampleContext) Sample_method() ISample_methodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_methodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_methodContext) +} + +func (s *SampleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SampleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SampleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSample(s) + } +} + +func (s *SampleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSample(s) + } +} + +func (s *SampleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSample(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Sample() (localctx ISampleContext) { + localctx = NewSampleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1048, SnowflakeParserRULE_sample) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11725) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserSAMPLE || _la == SnowflakeParserTABLESAMPLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserBERNOULLI || _la == SnowflakeParserBLOCK || _la == SnowflakeParserROW || _la == SnowflakeParserSYSTEM { + { + p.SetState(11726) + p.Sample_method() + } + + } + { + p.SetState(11729) + p.Sample_opts() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISearch_conditionContext is an interface to support dynamic dispatch. +type ISearch_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Predicate() IPredicateContext + LR_BRACKET() antlr.TerminalNode + AllSearch_condition() []ISearch_conditionContext + Search_condition(i int) ISearch_conditionContext + RR_BRACKET() antlr.TerminalNode + AllNOT() []antlr.TerminalNode + NOT(i int) antlr.TerminalNode + AND() antlr.TerminalNode + OR() antlr.TerminalNode + + // IsSearch_conditionContext differentiates from other interfaces. + IsSearch_conditionContext() +} + +type Search_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySearch_conditionContext() *Search_conditionContext { + var p = new(Search_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_search_condition + return p +} + +func InitEmptySearch_conditionContext(p *Search_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_search_condition +} + +func (*Search_conditionContext) IsSearch_conditionContext() {} + +func NewSearch_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_conditionContext { + var p = new(Search_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_search_condition + + return p +} + +func (s *Search_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Search_conditionContext) Predicate() IPredicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPredicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPredicateContext) +} + +func (s *Search_conditionContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Search_conditionContext) AllSearch_condition() []ISearch_conditionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISearch_conditionContext); ok { + len++ + } + } + + tst := make([]ISearch_conditionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISearch_conditionContext); ok { + tst[i] = t.(ISearch_conditionContext) + i++ + } + } + + return tst +} + +func (s *Search_conditionContext) Search_condition(i int) ISearch_conditionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +func (s *Search_conditionContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Search_conditionContext) AllNOT() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserNOT) +} + +func (s *Search_conditionContext) NOT(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, i) +} + +func (s *Search_conditionContext) AND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAND, 0) +} + +func (s *Search_conditionContext) OR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOR, 0) +} + +func (s *Search_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Search_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Search_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSearch_condition(s) + } +} + +func (s *Search_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSearch_condition(s) + } +} + +func (s *Search_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSearch_condition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Search_condition() (localctx ISearch_conditionContext) { + return p.search_condition(0) +} + +func (p *SnowflakeParser) search_condition(_p int) (localctx ISearch_conditionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewSearch_conditionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx ISearch_conditionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 1050 + p.EnterRecursionRule(localctx, 1050, SnowflakeParserRULE_search_condition, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1515, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11732) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1515, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(11743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1516, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11738) + p.Predicate() + } + + case 2: + { + p.SetState(11739) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11740) + p.search_condition(0) + } + { + p.SetState(11741) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(11753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1518, 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(11751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1517, p.GetParserRuleContext()) { + case 1: + localctx = NewSearch_conditionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_search_condition) + p.SetState(11745) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(11746) + p.Match(SnowflakeParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11747) + p.search_condition(3) + } + + case 2: + localctx = NewSearch_conditionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, SnowflakeParserRULE_search_condition) + p.SetState(11748) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(11749) + p.Match(SnowflakeParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11750) + p.search_condition(2) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(11755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1518, 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 +} + +// IComparison_operatorContext is an interface to support dynamic dispatch. +type IComparison_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQ() antlr.TerminalNode + GT() antlr.TerminalNode + LT() antlr.TerminalNode + LE() antlr.TerminalNode + GE() antlr.TerminalNode + LTGT() antlr.TerminalNode + NE() antlr.TerminalNode + + // IsComparison_operatorContext differentiates from other interfaces. + IsComparison_operatorContext() +} + +type Comparison_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComparison_operatorContext() *Comparison_operatorContext { + var p = new(Comparison_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_comparison_operator + return p +} + +func InitEmptyComparison_operatorContext(p *Comparison_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_comparison_operator +} + +func (*Comparison_operatorContext) IsComparison_operatorContext() {} + +func NewComparison_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comparison_operatorContext { + var p = new(Comparison_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_comparison_operator + + return p +} + +func (s *Comparison_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comparison_operatorContext) EQ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQ, 0) +} + +func (s *Comparison_operatorContext) GT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGT, 0) +} + +func (s *Comparison_operatorContext) LT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLT, 0) +} + +func (s *Comparison_operatorContext) LE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLE, 0) +} + +func (s *Comparison_operatorContext) GE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGE, 0) +} + +func (s *Comparison_operatorContext) LTGT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLTGT, 0) +} + +func (s *Comparison_operatorContext) NE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNE, 0) +} + +func (s *Comparison_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comparison_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comparison_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterComparison_operator(s) + } +} + +func (s *Comparison_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitComparison_operator(s) + } +} + +func (s *Comparison_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitComparison_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Comparison_operator() (localctx IComparison_operatorContext) { + localctx = NewComparison_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1052, SnowflakeParserRULE_comparison_operator) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11756) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1090)) & ^0x3f) == 0 && ((int64(1)<<(_la-1090))&127) != 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 +} + +// INull_not_nullContext is an interface to support dynamic dispatch. +type INull_not_nullContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsNull_not_nullContext differentiates from other interfaces. + IsNull_not_nullContext() +} + +type Null_not_nullContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNull_not_nullContext() *Null_not_nullContext { + var p = new(Null_not_nullContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_null_not_null + return p +} + +func InitEmptyNull_not_nullContext(p *Null_not_nullContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_null_not_null +} + +func (*Null_not_nullContext) IsNull_not_nullContext() {} + +func NewNull_not_nullContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Null_not_nullContext { + var p = new(Null_not_nullContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_null_not_null + + return p +} + +func (s *Null_not_nullContext) GetParser() antlr.Parser { return s.parser } + +func (s *Null_not_nullContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Null_not_nullContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *Null_not_nullContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Null_not_nullContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Null_not_nullContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterNull_not_null(s) + } +} + +func (s *Null_not_nullContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitNull_not_null(s) + } +} + +func (s *Null_not_nullContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitNull_not_null(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Null_not_null() (localctx INull_not_nullContext) { + localctx = NewNull_not_nullContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1054, SnowflakeParserRULE_null_not_null) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(11758) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11761) + p.Match(SnowflakeParserNULL_) + 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 +} + +// ISubqueryContext is an interface to support dynamic dispatch. +type ISubqueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_statement() IQuery_statementContext + + // IsSubqueryContext differentiates from other interfaces. + IsSubqueryContext() +} + +type SubqueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubqueryContext() *SubqueryContext { + var p = new(SubqueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_subquery + return p +} + +func InitEmptySubqueryContext(p *SubqueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_subquery +} + +func (*SubqueryContext) IsSubqueryContext() {} + +func NewSubqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SubqueryContext { + var p = new(SubqueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_subquery + + return p +} + +func (s *SubqueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *SubqueryContext) Query_statement() IQuery_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_statementContext) +} + +func (s *SubqueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SubqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SubqueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSubquery(s) + } +} + +func (s *SubqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSubquery(s) + } +} + +func (s *SubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSubquery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Subquery() (localctx ISubqueryContext) { + localctx = NewSubqueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1056, SnowflakeParserRULE_subquery) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11763) + p.Query_statement() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPredicateContext is an interface to support dynamic dispatch. +type IPredicateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXISTS() antlr.TerminalNode + LR_BRACKET() antlr.TerminalNode + Subquery() ISubqueryContext + RR_BRACKET() antlr.TerminalNode + AllExpr() []IExprContext + Expr(i int) IExprContext + Comparison_operator() IComparison_operatorContext + ALL() antlr.TerminalNode + SOME() antlr.TerminalNode + ANY() antlr.TerminalNode + BETWEEN() antlr.TerminalNode + AND() antlr.TerminalNode + NOT() antlr.TerminalNode + IN() antlr.TerminalNode + Expr_list() IExpr_listContext + LIKE() antlr.TerminalNode + ILIKE() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + RLIKE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + IS() antlr.TerminalNode + Null_not_null() INull_not_nullContext + + // IsPredicateContext differentiates from other interfaces. + IsPredicateContext() +} + +type PredicateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPredicateContext() *PredicateContext { + var p = new(PredicateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_predicate + return p +} + +func InitEmptyPredicateContext(p *PredicateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_predicate +} + +func (*PredicateContext) IsPredicateContext() {} + +func NewPredicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PredicateContext { + var p = new(PredicateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_predicate + + return p +} + +func (s *PredicateContext) GetParser() antlr.Parser { return s.parser } + +func (s *PredicateContext) EXISTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXISTS, 0) +} + +func (s *PredicateContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *PredicateContext) Subquery() ISubqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubqueryContext) +} + +func (s *PredicateContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *PredicateContext) AllExpr() []IExprContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExprContext); ok { + len++ + } + } + + tst := make([]IExprContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExprContext); ok { + tst[i] = t.(IExprContext) + i++ + } + } + + return tst +} + +func (s *PredicateContext) Expr(i int) IExprContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *PredicateContext) Comparison_operator() IComparison_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComparison_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComparison_operatorContext) +} + +func (s *PredicateContext) ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALL, 0) +} + +func (s *PredicateContext) SOME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSOME, 0) +} + +func (s *PredicateContext) ANY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserANY, 0) +} + +func (s *PredicateContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBETWEEN, 0) +} + +func (s *PredicateContext) AND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAND, 0) +} + +func (s *PredicateContext) NOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOT, 0) +} + +func (s *PredicateContext) IN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIN, 0) +} + +func (s *PredicateContext) 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 *PredicateContext) LIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIKE, 0) +} + +func (s *PredicateContext) ILIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserILIKE, 0) +} + +func (s *PredicateContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserESCAPE, 0) +} + +func (s *PredicateContext) RLIKE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRLIKE, 0) +} + +func (s *PredicateContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *PredicateContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *PredicateContext) IS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIS, 0) +} + +func (s *PredicateContext) Null_not_null() INull_not_nullContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_not_nullContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_not_nullContext) +} + +func (s *PredicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PredicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PredicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterPredicate(s) + } +} + +func (s *PredicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitPredicate(s) + } +} + +func (s *PredicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitPredicate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Predicate() (localctx IPredicateContext) { + localctx = NewPredicateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1058, SnowflakeParserRULE_predicate) + var _la int + + p.SetState(11844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1529, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11765) + p.Match(SnowflakeParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11766) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11767) + p.Subquery() + } + { + p.SetState(11768) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11770) + p.expr(0) + } + { + p.SetState(11771) + p.Comparison_operator() + } + { + p.SetState(11772) + p.expr(0) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11774) + p.expr(0) + } + { + p.SetState(11775) + p.Comparison_operator() + } + { + p.SetState(11776) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserALL || _la == SnowflakeParserANY || _la == SnowflakeParserSOME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11777) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11778) + p.Subquery() + } + { + p.SetState(11779) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11781) + p.expr(0) + } + p.SetState(11783) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(11782) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11785) + p.Match(SnowflakeParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11786) + p.expr(0) + } + { + p.SetState(11787) + p.Match(SnowflakeParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11788) + p.expr(0) + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11790) + p.expr(0) + } + p.SetState(11792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(11791) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11794) + p.Match(SnowflakeParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11795) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1522, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11796) + p.Subquery() + } + + case 2: + { + p.SetState(11797) + p.Expr_list() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11800) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11802) + p.expr(0) + } + p.SetState(11804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(11803) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11806) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserILIKE || _la == SnowflakeParserLIKE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11807) + p.expr(0) + } + p.SetState(11810) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1524, p.GetParserRuleContext()) == 1 { + { + p.SetState(11808) + p.Match(SnowflakeParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11809) + p.expr(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11812) + p.expr(0) + } + p.SetState(11814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(11813) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11816) + p.Match(SnowflakeParserRLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11817) + p.expr(0) + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(11819) + p.expr(0) + } + p.SetState(11821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserNOT { + { + p.SetState(11820) + p.Match(SnowflakeParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11823) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserILIKE || _la == SnowflakeParserLIKE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11824) + p.Match(SnowflakeParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11825) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11826) + p.expr(0) + } + p.SetState(11831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11827) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11828) + p.expr(0) + } + + p.SetState(11833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11834) + p.Match(SnowflakeParserRR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11837) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1528, p.GetParserRuleContext()) == 1 { + { + p.SetState(11835) + p.Match(SnowflakeParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11836) + p.expr(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(11839) + p.expr(0) + } + { + p.SetState(11840) + p.Match(SnowflakeParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11841) + p.Null_not_null() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(11843) + p.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 +} + +// 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 + Search_condition() ISearch_conditionContext + + // 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 = SnowflakeParserRULE_where_clause + return p +} + +func InitEmptyWhere_clauseContext(p *Where_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_where_clause + + return p +} + +func (s *Where_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Where_clauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWHERE, 0) +} + +func (s *Where_clauseContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +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.(SnowflakeParserListener); ok { + listenerT.EnterWhere_clause(s) + } +} + +func (s *Where_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitWhere_clause(s) + } +} + +func (s *Where_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitWhere_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Where_clause() (localctx IWhere_clauseContext) { + localctx = NewWhere_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1060, SnowflakeParserRULE_where_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11846) + p.Match(SnowflakeParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11847) + p.search_condition(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_itemContext is an interface to support dynamic dispatch. +type IGroup_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + Num() INumContext + Expr() IExprContext + + // IsGroup_itemContext differentiates from other interfaces. + IsGroup_itemContext() +} + +type Group_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_itemContext() *Group_itemContext { + var p = new(Group_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_group_item + return p +} + +func InitEmptyGroup_itemContext(p *Group_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_group_item +} + +func (*Group_itemContext) IsGroup_itemContext() {} + +func NewGroup_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_itemContext { + var p = new(Group_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_group_item + + return p +} + +func (s *Group_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_itemContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Group_itemContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Group_itemContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Group_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGroup_item(s) + } +} + +func (s *Group_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGroup_item(s) + } +} + +func (s *Group_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGroup_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Group_item() (localctx IGroup_itemContext) { + localctx = NewGroup_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1062, SnowflakeParserRULE_group_item) + p.SetState(11852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1530, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11849) + p.Id_() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11850) + p.Num() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11851) + p.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 +} + +// IGroup_by_clauseContext is an interface to support dynamic dispatch. +type IGroup_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + BY() antlr.TerminalNode + AllGroup_item() []IGroup_itemContext + Group_item(i int) IGroup_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Having_clause() IHaving_clauseContext + LR_BRACKET() antlr.TerminalNode + RR_BRACKET() antlr.TerminalNode + CUBE() antlr.TerminalNode + GROUPING() antlr.TerminalNode + SETS() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + + // IsGroup_by_clauseContext differentiates from other interfaces. + IsGroup_by_clauseContext() +} + +type Group_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_clauseContext() *Group_by_clauseContext { + var p = new(Group_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_group_by_clause + return p +} + +func InitEmptyGroup_by_clauseContext(p *Group_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_group_by_clause +} + +func (*Group_by_clauseContext) IsGroup_by_clauseContext() {} + +func NewGroup_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_clauseContext { + var p = new(Group_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_group_by_clause + + return p +} + +func (s *Group_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUP, 0) +} + +func (s *Group_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Group_by_clauseContext) AllGroup_item() []IGroup_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_itemContext); ok { + len++ + } + } + + tst := make([]IGroup_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_itemContext); ok { + tst[i] = t.(IGroup_itemContext) + i++ + } + } + + return tst +} + +func (s *Group_by_clauseContext) Group_item(i int) IGroup_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_itemContext) +} + +func (s *Group_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Group_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Group_by_clauseContext) 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 *Group_by_clauseContext) LR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLR_BRACKET, 0) +} + +func (s *Group_by_clauseContext) RR_BRACKET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRR_BRACKET, 0) +} + +func (s *Group_by_clauseContext) CUBE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCUBE, 0) +} + +func (s *Group_by_clauseContext) GROUPING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUPING, 0) +} + +func (s *Group_by_clauseContext) SETS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSETS, 0) +} + +func (s *Group_by_clauseContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLLUP, 0) +} + +func (s *Group_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitGroup_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Group_by_clause() (localctx IGroup_by_clauseContext) { + localctx = NewGroup_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1064, SnowflakeParserRULE_group_by_clause) + var _la int + + var _alt int + + p.SetState(11886) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1535, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11854) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11855) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11856) + p.Group_item() + } + p.SetState(11861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1531, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11857) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11858) + p.Group_item() + } + + } + p.SetState(11863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1531, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(11865) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1532, p.GetParserRuleContext()) == 1 { + { + p.SetState(11864) + p.Having_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11867) + p.Match(SnowflakeParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11868) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserCUBE: + { + p.SetState(11869) + p.Match(SnowflakeParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserGROUPING: + { + p.SetState(11870) + p.Match(SnowflakeParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11871) + p.Match(SnowflakeParserSETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case SnowflakeParserROLLUP: + { + p.SetState(11872) + p.Match(SnowflakeParserROLLUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11875) + p.Match(SnowflakeParserLR_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11876) + p.Group_item() + } + p.SetState(11881) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == SnowflakeParserCOMMA { + { + p.SetState(11877) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11878) + p.Group_item() + } + + p.SetState(11883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11884) + p.Match(SnowflakeParserRR_BRACKET) + 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 +} + +// 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 + Search_condition() ISearch_conditionContext + + // 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 = SnowflakeParserRULE_having_clause + return p +} + +func InitEmptyHaving_clauseContext(p *Having_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_having_clause + + return p +} + +func (s *Having_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Having_clauseContext) HAVING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHAVING, 0) +} + +func (s *Having_clauseContext) Search_condition() ISearch_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_conditionContext) +} + +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.(SnowflakeParserListener); ok { + listenerT.EnterHaving_clause(s) + } +} + +func (s *Having_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitHaving_clause(s) + } +} + +func (s *Having_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitHaving_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Having_clause() (localctx IHaving_clauseContext) { + localctx = NewHaving_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1066, SnowflakeParserRULE_having_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11888) + p.Match(SnowflakeParserHAVING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11889) + p.search_condition(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualify_clauseContext is an interface to support dynamic dispatch. +type IQualify_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUALIFY() antlr.TerminalNode + Expr() IExprContext + + // IsQualify_clauseContext differentiates from other interfaces. + IsQualify_clauseContext() +} + +type Qualify_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualify_clauseContext() *Qualify_clauseContext { + var p = new(Qualify_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_qualify_clause + return p +} + +func InitEmptyQualify_clauseContext(p *Qualify_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_qualify_clause +} + +func (*Qualify_clauseContext) IsQualify_clauseContext() {} + +func NewQualify_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualify_clauseContext { + var p = new(Qualify_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_qualify_clause + + return p +} + +func (s *Qualify_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualify_clauseContext) QUALIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUALIFY, 0) +} + +func (s *Qualify_clauseContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Qualify_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualify_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualify_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterQualify_clause(s) + } +} + +func (s *Qualify_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitQualify_clause(s) + } +} + +func (s *Qualify_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitQualify_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Qualify_clause() (localctx IQualify_clauseContext) { + localctx = NewQualify_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1068, SnowflakeParserRULE_qualify_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11891) + p.Match(SnowflakeParserQUALIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11892) + p.expr(0) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOrder_itemContext is an interface to support dynamic dispatch. +type IOrder_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_() IId_Context + Num() INumContext + Expr() IExprContext + NULLS() antlr.TerminalNode + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + + // IsOrder_itemContext differentiates from other interfaces. + IsOrder_itemContext() +} + +type Order_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_itemContext() *Order_itemContext { + var p = new(Order_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_order_item + return p +} + +func InitEmptyOrder_itemContext(p *Order_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_order_item +} + +func (*Order_itemContext) IsOrder_itemContext() {} + +func NewOrder_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_itemContext { + var p = new(Order_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_order_item + + return p +} + +func (s *Order_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_itemContext) Id_() IId_Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_Context) +} + +func (s *Order_itemContext) Num() INumContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Order_itemContext) Expr() IExprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExprContext) +} + +func (s *Order_itemContext) NULLS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULLS, 0) +} + +func (s *Order_itemContext) ASC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASC, 0) +} + +func (s *Order_itemContext) DESC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDESC, 0) +} + +func (s *Order_itemContext) FIRST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIRST, 0) +} + +func (s *Order_itemContext) LAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST, 0) +} + +func (s *Order_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterOrder_item(s) + } +} + +func (s *Order_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitOrder_item(s) + } +} + +func (s *Order_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitOrder_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Order_item() (localctx IOrder_itemContext) { + localctx = NewOrder_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1070, SnowflakeParserRULE_order_item) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1536, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11894) + p.Id_() + } + + case 2: + { + p.SetState(11895) + p.Num() + } + + case 3: + { + p.SetState(11896) + p.expr(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(11900) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1537, p.GetParserRuleContext()) == 1 { + { + p.SetState(11899) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserASC || _la == SnowflakeParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11904) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1538, p.GetParserRuleContext()) == 1 { + { + p.SetState(11902) + p.Match(SnowflakeParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11903) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserFIRST || _la == SnowflakeParserLAST) { + 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 +} + +// IOrder_by_clauseContext is an interface to support dynamic dispatch. +type IOrder_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllOrder_item() []IOrder_itemContext + Order_item(i int) IOrder_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOrder_by_clauseContext differentiates from other interfaces. + IsOrder_by_clauseContext() +} + +type Order_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_by_clauseContext() *Order_by_clauseContext { + var p = new(Order_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_order_by_clause + return p +} + +func InitEmptyOrder_by_clauseContext(p *Order_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_order_by_clause +} + +func (*Order_by_clauseContext) IsOrder_by_clauseContext() {} + +func NewOrder_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_clauseContext { + var p = new(Order_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_order_by_clause + + return p +} + +func (s *Order_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORDER, 0) +} + +func (s *Order_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBY, 0) +} + +func (s *Order_by_clauseContext) AllOrder_item() []IOrder_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrder_itemContext); ok { + len++ + } + } + + tst := make([]IOrder_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrder_itemContext); ok { + tst[i] = t.(IOrder_itemContext) + i++ + } + } + + return tst +} + +func (s *Order_by_clauseContext) Order_item(i int) IOrder_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrder_itemContext) +} + +func (s *Order_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(SnowflakeParserCOMMA) +} + +func (s *Order_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMA, i) +} + +func (s *Order_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitOrder_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Order_by_clause() (localctx IOrder_by_clauseContext) { + localctx = NewOrder_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1072, SnowflakeParserRULE_order_by_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11906) + p.Match(SnowflakeParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11907) + p.Match(SnowflakeParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11908) + p.Order_item() + } + p.SetState(11913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1539, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11909) + p.Match(SnowflakeParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11910) + p.Order_item() + } + + } + p.SetState(11915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1539, 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 +} + +// IRow_rowsContext is an interface to support dynamic dispatch. +type IRow_rowsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + ROWS() antlr.TerminalNode + + // IsRow_rowsContext differentiates from other interfaces. + IsRow_rowsContext() +} + +type Row_rowsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_rowsContext() *Row_rowsContext { + var p = new(Row_rowsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_row_rows + return p +} + +func InitEmptyRow_rowsContext(p *Row_rowsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_row_rows +} + +func (*Row_rowsContext) IsRow_rowsContext() {} + +func NewRow_rowsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_rowsContext { + var p = new(Row_rowsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_row_rows + + return p +} + +func (s *Row_rowsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_rowsContext) ROW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW, 0) +} + +func (s *Row_rowsContext) ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWS, 0) +} + +func (s *Row_rowsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_rowsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_rowsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterRow_rows(s) + } +} + +func (s *Row_rowsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitRow_rows(s) + } +} + +func (s *Row_rowsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitRow_rows(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Row_rows() (localctx IRow_rowsContext) { + localctx = NewRow_rowsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1074, SnowflakeParserRULE_row_rows) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11916) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserROW || _la == SnowflakeParserROWS) { + 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_nextContext is an interface to support dynamic dispatch. +type IFirst_nextContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FIRST() antlr.TerminalNode + NEXT() antlr.TerminalNode + + // IsFirst_nextContext differentiates from other interfaces. + IsFirst_nextContext() +} + +type First_nextContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFirst_nextContext() *First_nextContext { + var p = new(First_nextContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_first_next + return p +} + +func InitEmptyFirst_nextContext(p *First_nextContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_first_next +} + +func (*First_nextContext) IsFirst_nextContext() {} + +func NewFirst_nextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *First_nextContext { + var p = new(First_nextContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_first_next + + return p +} + +func (s *First_nextContext) GetParser() antlr.Parser { return s.parser } + +func (s *First_nextContext) FIRST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIRST, 0) +} + +func (s *First_nextContext) NEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEXT, 0) +} + +func (s *First_nextContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *First_nextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *First_nextContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterFirst_next(s) + } +} + +func (s *First_nextContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitFirst_next(s) + } +} + +func (s *First_nextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitFirst_next(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) First_next() (localctx IFirst_nextContext) { + localctx = NewFirst_nextContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1076, SnowflakeParserRULE_first_next) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11918) + _la = p.GetTokenStream().LA(1) + + if !(_la == SnowflakeParserFIRST || _la == SnowflakeParserNEXT) { + 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 +} + +// 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 + AllNum() []INumContext + Num(i int) INumContext + OFFSET() antlr.TerminalNode + FETCH() antlr.TerminalNode + AllRow_rows() []IRow_rowsContext + Row_rows(i int) IRow_rowsContext + First_next() IFirst_nextContext + ONLY() 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 = SnowflakeParserRULE_limit_clause + return p +} + +func InitEmptyLimit_clauseContext(p *Limit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_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 = SnowflakeParserRULE_limit_clause + + return p +} + +func (s *Limit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Limit_clauseContext) LIMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIMIT, 0) +} + +func (s *Limit_clauseContext) AllNum() []INumContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumContext); ok { + len++ + } + } + + tst := make([]INumContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumContext); ok { + tst[i] = t.(INumContext) + i++ + } + } + + return tst +} + +func (s *Limit_clauseContext) Num(i int) INumContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumContext) +} + +func (s *Limit_clauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFFSET, 0) +} + +func (s *Limit_clauseContext) FETCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFETCH, 0) +} + +func (s *Limit_clauseContext) AllRow_rows() []IRow_rowsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRow_rowsContext); ok { + len++ + } + } + + tst := make([]IRow_rowsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRow_rowsContext); ok { + tst[i] = t.(IRow_rowsContext) + i++ + } + } + + return tst +} + +func (s *Limit_clauseContext) Row_rows(i int) IRow_rowsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_rowsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRow_rowsContext) +} + +func (s *Limit_clauseContext) First_next() IFirst_nextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFirst_nextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFirst_nextContext) +} + +func (s *Limit_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserONLY, 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.(SnowflakeParserListener); ok { + listenerT.EnterLimit_clause(s) + } +} + +func (s *Limit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitLimit_clause(s) + } +} + +func (s *Limit_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitLimit_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Limit_clause() (localctx ILimit_clauseContext) { + localctx = NewLimit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1078, SnowflakeParserRULE_limit_clause) + var _la int + + p.SetState(11944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case SnowflakeParserLIMIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11920) + p.Match(SnowflakeParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11921) + p.Num() + } + p.SetState(11924) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1540, p.GetParserRuleContext()) == 1 { + { + p.SetState(11922) + p.Match(SnowflakeParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11923) + p.Num() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case SnowflakeParserFETCH, SnowflakeParserOFFSET, SnowflakeParserROW, SnowflakeParserROWS: + p.EnterOuterAlt(localctx, 2) + p.SetState(11928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserOFFSET { + { + p.SetState(11926) + p.Match(SnowflakeParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11927) + p.Num() + } + + } + p.SetState(11931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserROW || _la == SnowflakeParserROWS { + { + p.SetState(11930) + p.Row_rows() + } + + } + { + p.SetState(11933) + p.Match(SnowflakeParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11935) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == SnowflakeParserFIRST || _la == SnowflakeParserNEXT { + { + p.SetState(11934) + p.First_next() + } + + } + { + p.SetState(11937) + p.Num() + } + p.SetState(11939) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1544, p.GetParserRuleContext()) == 1 { + { + p.SetState(11938) + p.Row_rows() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11942) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1545, p.GetParserRuleContext()) == 1 { + { + p.SetState(11941) + p.Match(SnowflakeParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } 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 +} + +// ISupplement_non_reserved_wordsContext is an interface to support dynamic dispatch. +type ISupplement_non_reserved_wordsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AAD_PROVISIONER_Q() antlr.TerminalNode + ABORT() antlr.TerminalNode + ABORT_AFTER_WAIT() antlr.TerminalNode + ABORT_DETACHED_QUERY() antlr.TerminalNode + ABORT_STATEMENT() antlr.TerminalNode + ABSENT() antlr.TerminalNode + ABSOLUTE() antlr.TerminalNode + ACCESS() antlr.TerminalNode + ACCOUNTADMIN() antlr.TerminalNode + ACCOUNTS() antlr.TerminalNode + ACTION() antlr.TerminalNode + ACTIVE() antlr.TerminalNode + ADD() antlr.TerminalNode + ADMINISTER() antlr.TerminalNode + ADMIN_NAME() antlr.TerminalNode + ADMIN_PASSWORD() antlr.TerminalNode + AES() antlr.TerminalNode + AFTER() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + ALERT() antlr.TerminalNode + ALERTS() antlr.TerminalNode + ALLOWED() antlr.TerminalNode + ALLOWED_ACCOUNTS() antlr.TerminalNode + ALLOWED_DATABASES() antlr.TerminalNode + ALLOWED_INTEGRATION_TYPES() antlr.TerminalNode + ALLOWED_IP_LIST() antlr.TerminalNode + ALLOWED_SHARES() antlr.TerminalNode + ALLOWED_VALUES() antlr.TerminalNode + ALLOW_CLIENT_MFA_CACHING() antlr.TerminalNode + ALLOW_CONNECTIONS() antlr.TerminalNode + ALLOW_DUPLICATE() antlr.TerminalNode + ALLOW_ID_TOKEN() antlr.TerminalNode + ALLOW_MULTIPLE_EVENT_LOSS() antlr.TerminalNode + ALLOW_OVERLAPPING_EXECUTION() antlr.TerminalNode + ALLOW_SINGLE_EVENT_LOSS() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + ANONYMOUS() antlr.TerminalNode + ANSI_DEFAULTS() antlr.TerminalNode + API() antlr.TerminalNode + API_ALLOWED_PREFIXES() antlr.TerminalNode + API_AWS_ROLE_ARN() antlr.TerminalNode + API_BLOCKED_PREFIXES() antlr.TerminalNode + API_INTEGRATION() antlr.TerminalNode + API_KEY() antlr.TerminalNode + API_PROVIDER() antlr.TerminalNode + APPEND() antlr.TerminalNode + APPEND_ONLY() antlr.TerminalNode + APPLICATION() antlr.TerminalNode + APPLY() antlr.TerminalNode + APP_NAME() antlr.TerminalNode + ASC() antlr.TerminalNode + ATTACH() antlr.TerminalNode + AT_KEYWORD() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + AUTHORIZATIONS() antlr.TerminalNode + AUTO() antlr.TerminalNode + AUTO_Q() antlr.TerminalNode + AUTOCOMMIT() antlr.TerminalNode + AUTOCOMMIT_API_SUPPORTED() antlr.TerminalNode + AUTOINCREMENT() antlr.TerminalNode + AUTO_COMPRESS() antlr.TerminalNode + AUTO_DETECT() antlr.TerminalNode + AUTO_INGEST() antlr.TerminalNode + AUTO_REFRESH() antlr.TerminalNode + AUTO_RESUME() antlr.TerminalNode + AUTO_SUSPEND() antlr.TerminalNode + AVG() antlr.TerminalNode + AVRO() antlr.TerminalNode + AVRO_Q() antlr.TerminalNode + AWS_KEY_ID() antlr.TerminalNode + AWS_ROLE() antlr.TerminalNode + AWS_SECRET_KEY() antlr.TerminalNode + AWS_SNS() antlr.TerminalNode + AWS_SNS_ROLE_ARN() antlr.TerminalNode + AWS_SNS_TOPIC() antlr.TerminalNode + AWS_SNS_TOPIC_ARN() antlr.TerminalNode + AWS_TOKEN() antlr.TerminalNode + AZURE() antlr.TerminalNode + AZURE_AD_APPLICATION_ID() antlr.TerminalNode + AZURE_EVENT_GRID() antlr.TerminalNode + AZURE_EVENT_GRID_TOPIC_ENDPOINT() antlr.TerminalNode + AZURE_Q() antlr.TerminalNode + AZURE_SAS_TOKEN() antlr.TerminalNode + AZURE_STORAGE_QUEUE_PRIMARY_URI() antlr.TerminalNode + AZURE_TENANT_ID() antlr.TerminalNode + BEFORE() antlr.TerminalNode + BEGIN() antlr.TerminalNode + BERNOULLI() antlr.TerminalNode + BINARY_AS_TEXT() antlr.TerminalNode + BINARY_CHECKSUM() antlr.TerminalNode + BINARY_FORMAT() antlr.TerminalNode + BINARY_INPUT_FORMAT() antlr.TerminalNode + BINARY_OUTPUT_FORMAT() antlr.TerminalNode + BINDING() antlr.TerminalNode + BLOCK() antlr.TerminalNode + BLOCKED_IP_LIST() antlr.TerminalNode + BLOCKED_ROLES_LIST() antlr.TerminalNode + BODY() antlr.TerminalNode + BOTH_Q() antlr.TerminalNode + BROTLI() antlr.TerminalNode + BUSINESS_CRITICAL() antlr.TerminalNode + CACHE() antlr.TerminalNode + CALL() antlr.TerminalNode + CALLED() antlr.TerminalNode + CALLER() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CASE_INSENSITIVE() antlr.TerminalNode + CASE_SENSITIVE() antlr.TerminalNode + CATCH() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + CHANGE() antlr.TerminalNode + CHANGES() antlr.TerminalNode + CHANGETABLE() antlr.TerminalNode + CHANGE_RETENTION() antlr.TerminalNode + CHANGE_TRACKING() antlr.TerminalNode + CHAR() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + CHARINDEX() antlr.TerminalNode + CHECKSUM() antlr.TerminalNode + CHECKSUM_AGG() antlr.TerminalNode + CHECK_EXPIRATION() antlr.TerminalNode + CHECK_POLICY() antlr.TerminalNode + CLASSIFIER_FUNCTION() antlr.TerminalNode + CLEANUP() antlr.TerminalNode + CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS() antlr.TerminalNode + CLIENT_ENCRYPTION_KEY_SIZE() antlr.TerminalNode + CLIENT_MEMORY_LIMIT() antlr.TerminalNode + CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX() antlr.TerminalNode + CLIENT_METADATA_USE_SESSION_DATABASE() antlr.TerminalNode + CLIENT_PREFETCH_THREADS() antlr.TerminalNode + CLIENT_RESULT_CHUNK_SIZE() antlr.TerminalNode + CLIENT_RESULT_COLUMN_CASE_INSENSITIVE() antlr.TerminalNode + CLIENT_SESSION_KEEP_ALIVE() antlr.TerminalNode + CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY() antlr.TerminalNode + CLIENT_TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode + CLONE() antlr.TerminalNode + CLOSE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + CLUSTERED() antlr.TerminalNode + CLUSTERING() antlr.TerminalNode + COALESCE() antlr.TerminalNode + COLLATE() antlr.TerminalNode + COLLECTION() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + COL_LENGTH() antlr.TerminalNode + COL_NAME() antlr.TerminalNode + COMMENT() antlr.TerminalNode + COMMIT() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + COMPRESSION() antlr.TerminalNode + CONCAT() antlr.TerminalNode + CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode + CONCAT_WS() antlr.TerminalNode + CONDITION() antlr.TerminalNode + CONFIGURATION() antlr.TerminalNode + CONNECTIONS() antlr.TerminalNode + CONTAINMENT() antlr.TerminalNode + CONTAINS() antlr.TerminalNode + CONTENT() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + CONTEXT_HEADERS() antlr.TerminalNode + CONTEXT_INFO() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + CONTROL() antlr.TerminalNode + CONVERSATION() antlr.TerminalNode + COOKIE() antlr.TerminalNode + COPY() antlr.TerminalNode + COPY_ONLY() antlr.TerminalNode + COPY_OPTIONS_() antlr.TerminalNode + COUNT() antlr.TerminalNode + COUNT_BIG() antlr.TerminalNode + CREDENTIALS() antlr.TerminalNode + CREDIT_QUOTA() antlr.TerminalNode + CSV() antlr.TerminalNode + CSV_Q() antlr.TerminalNode + CUBE() antlr.TerminalNode + CUME_DIST() antlr.TerminalNode + CURSOR() antlr.TerminalNode + CUSTOM() antlr.TerminalNode + DAILY() antlr.TerminalNode + DATA() antlr.TerminalNode + DATABASES() antlr.TerminalNode + DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + DATEADD() antlr.TerminalNode + DATEDIFF() antlr.TerminalNode + DATENAME() antlr.TerminalNode + DATEPART() antlr.TerminalNode + DATE_FORMAT() antlr.TerminalNode + DATE_INPUT_FORMAT() antlr.TerminalNode + DATE_OUTPUT_FORMAT() antlr.TerminalNode + DATE_PART() antlr.TerminalNode + DAYS() antlr.TerminalNode + DAYS_TO_EXPIRY() antlr.TerminalNode + DECLARE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + DEFAULT_DDL_COLLATION_() antlr.TerminalNode + DEFAULT_NAMESPACE() antlr.TerminalNode + DEFAULT_ROLE() antlr.TerminalNode + DEFAULT_WAREHOUSE() antlr.TerminalNode + DEFERRABLE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + DEFINE() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + DEFLATE() antlr.TerminalNode + DELEGATED() antlr.TerminalNode + DELTA() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + DESC() antlr.TerminalNode + DESCRIBE() antlr.TerminalNode + DIRECTION() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + DISABLE() antlr.TerminalNode + DISABLED() antlr.TerminalNode + DISABLE_AUTO_CONVERT() antlr.TerminalNode + DISABLE_SNOWFLAKE_DATA() antlr.TerminalNode + DISK() antlr.TerminalNode + DISPLAY_NAME() antlr.TerminalNode + DO() antlr.TerminalNode + DOWNSTREAM() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + ECONOMY() antlr.TerminalNode + EDITION() antlr.TerminalNode + EMAIL() antlr.TerminalNode + EMPTY_() antlr.TerminalNode + EMPTY_FIELD_AS_NULL() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENABLED() antlr.TerminalNode + ENABLE_FOR_PRIVILEGE() antlr.TerminalNode + ENABLE_INTERNAL_STAGES_PRIVATELINK() antlr.TerminalNode + ENABLE_OCTAL() antlr.TerminalNode + ENABLE_QUERY_ACCELERATION() antlr.TerminalNode + ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION() antlr.TerminalNode + ENCODING() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + END() antlr.TerminalNode + ENDPOINT() antlr.TerminalNode + END_TIMESTAMP() antlr.TerminalNode + ENFORCED() antlr.TerminalNode + ENFORCE_LENGTH() antlr.TerminalNode + ENFORCE_SESSION_POLICY() antlr.TerminalNode + ENTERPRISE() antlr.TerminalNode + EQUALITY() antlr.TerminalNode + ERROR_INTEGRATION() antlr.TerminalNode + ERROR_ON_COLUMN_COUNT_MISMATCH() antlr.TerminalNode + ERROR_ON_NONDETERMINISTIC_MERGE() antlr.TerminalNode + ERROR_ON_NONDETERMINISTIC_UPDATE() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + ESCAPE_UNENCLOSED_FIELD() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + EXCHANGE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + EXECUTION() antlr.TerminalNode + EXIST() antlr.TerminalNode + EXIT() antlr.TerminalNode + EXPAND() antlr.TerminalNode + EXPIRY_DATE() antlr.TerminalNode + EXPLAIN() antlr.TerminalNode + EXPLICIT() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + EXTERNAL_OAUTH() antlr.TerminalNode + EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_ALLOWED_ROLES_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_ANY_ROLE_MODE() antlr.TerminalNode + EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_BLOCKED_ROLES_LIST() antlr.TerminalNode + EXTERNAL_OAUTH_ISSUER() antlr.TerminalNode + EXTERNAL_OAUTH_JWS_KEYS_URL() antlr.TerminalNode + EXTERNAL_OAUTH_RSA_PUBLIC_KEY() antlr.TerminalNode + EXTERNAL_OAUTH_SCOPE_DELIMITER() antlr.TerminalNode + EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE() antlr.TerminalNode + EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM() antlr.TerminalNode + EXTERNAL_OAUTH_TYPE() antlr.TerminalNode + EXTERNAL_STAGE() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + FAILOVER_MODE() antlr.TerminalNode + FAIL_OPERATION() antlr.TerminalNode + FETCH() antlr.TerminalNode + FIELD_DELIMITER() antlr.TerminalNode + FIELD_OPTIONALLY_ENCLOSED_BY() antlr.TerminalNode + FILE() antlr.TerminalNode + FILES() antlr.TerminalNode + FILE_EXTENSION() antlr.TerminalNode + FILE_FORMAT() antlr.TerminalNode + FILTER() antlr.TerminalNode + FIRST() antlr.TerminalNode + FIRST_NAME() antlr.TerminalNode + FLATTEN() antlr.TerminalNode + FORCE() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + FORMAT() antlr.TerminalNode + FORMATS() antlr.TerminalNode + FORMAT_NAME() antlr.TerminalNode + FREQUENCY() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + FUTURE() antlr.TerminalNode + GCP_PUBSUB() antlr.TerminalNode + GCP_PUBSUB_SUBSCRIPTION_NAME() antlr.TerminalNode + GCP_PUBSUB_TOPIC_NAME() antlr.TerminalNode + GCS() antlr.TerminalNode + GENERIC_Q() antlr.TerminalNode + GENERIC_SCIM_PROVISIONER_Q() antlr.TerminalNode + GEO() antlr.TerminalNode + GEOGRAPHY_OUTPUT_FORMAT() antlr.TerminalNode + GEOMETRY_OUTPUT_FORMAT() antlr.TerminalNode + GET() antlr.TerminalNode + GET_FILESTREAM_TRANSACTION_CONTEXT() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + GOOGLE_AUDIENCE() antlr.TerminalNode + GOTO() antlr.TerminalNode + GRANTS() antlr.TerminalNode + GROUPING() antlr.TerminalNode + GROUPING_ID() antlr.TerminalNode + GROUPS() antlr.TerminalNode + GZIP() antlr.TerminalNode + HEADER() antlr.TerminalNode + HEADERS() antlr.TerminalNode + HEX() antlr.TerminalNode + HIERARCHYID() antlr.TerminalNode + HIGH() antlr.TerminalNode + HISTORY() antlr.TerminalNode + HOURS() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + IF() antlr.TerminalNode + IFF() antlr.TerminalNode + IFNULL() antlr.TerminalNode + IGNORE() antlr.TerminalNode + IGNORE_CONSTRAINTS() antlr.TerminalNode + IGNORE_DUP_KEY() antlr.TerminalNode + IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX() antlr.TerminalNode + IGNORE_TRIGGERS() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + IMMEDIATELY() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + IMPLICIT() antlr.TerminalNode + IMPORT() antlr.TerminalNode + IMPORTED() antlr.TerminalNode + INDEX() antlr.TerminalNode + INFORMATION() antlr.TerminalNode + INIT() antlr.TerminalNode + INITIALLY() antlr.TerminalNode + INITIALLY_SUSPENDED() antlr.TerminalNode + INITIAL_REPLICATION_SIZE_LIMIT_IN_TB() antlr.TerminalNode + INPUT() antlr.TerminalNode + INSERT_ONLY() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + INT() antlr.TerminalNode + INTEGRATION() antlr.TerminalNode + INTEGRATIONS() antlr.TerminalNode + ISNULL() antlr.TerminalNode + ISNUMERIC() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + JAVASCRIPT() antlr.TerminalNode + JDBC_TREAT_DECIMAL_AS_INT() antlr.TerminalNode + JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC() antlr.TerminalNode + JDBC_USE_SESSION_TIMEZONE() antlr.TerminalNode + JSON() antlr.TerminalNode + JSON_Q() antlr.TerminalNode + JSON_INDENT() antlr.TerminalNode + JS_TREAT_INTEGER_AS_BIGINT() antlr.TerminalNode + KB() antlr.TerminalNode + KEEP() antlr.TerminalNode + KEY() antlr.TerminalNode + KEYS() antlr.TerminalNode + KEYSET() antlr.TerminalNode + KMS_KEY_ID() antlr.TerminalNode + LAG() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + LARGE() antlr.TerminalNode + LAST() antlr.TerminalNode + LAST_NAME() antlr.TerminalNode + LAST_QUERY_ID() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + LEAD() antlr.TerminalNode + LEN() antlr.TerminalNode + LENGTH() antlr.TerminalNode + LEVEL() antlr.TerminalNode + LIMIT() antlr.TerminalNode + LINENO() antlr.TerminalNode + LIST() antlr.TerminalNode + LISTENER_IP() antlr.TerminalNode + LISTENER_PORT() antlr.TerminalNode + LISTING() antlr.TerminalNode + LOAD() antlr.TerminalNode + LOCAL() antlr.TerminalNode + LOCAL_SERVICE_NAME() antlr.TerminalNode + LOCATION() antlr.TerminalNode + LOCKS() antlr.TerminalNode + LOCK_TIMEOUT() antlr.TerminalNode + LOG() antlr.TerminalNode + LOGIN() antlr.TerminalNode + LOGIN_NAME() antlr.TerminalNode + LOOKER() antlr.TerminalNode + LOW() antlr.TerminalNode + LOWER() antlr.TerminalNode + LTRIM() antlr.TerminalNode + LZO() antlr.TerminalNode + MANAGE() antlr.TerminalNode + MANAGED() antlr.TerminalNode + MASK() antlr.TerminalNode + MASKED() antlr.TerminalNode + MASKING() antlr.TerminalNode + MASTER() antlr.TerminalNode + MASTER_KEY() antlr.TerminalNode + MATCH() antlr.TerminalNode + MATCHED() antlr.TerminalNode + MATCHES() antlr.TerminalNode + MATCH_BY_COLUMN_NAME() antlr.TerminalNode + MATCH_RECOGNIZE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + MAX_BATCH_ROWS() antlr.TerminalNode + MAX_CLUSTER_COUNT() antlr.TerminalNode + MAX_CONCURRENCY_LEVEL() antlr.TerminalNode + MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode + MAX_SIZE() antlr.TerminalNode + MEASURES() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + MEMOIZABLE() antlr.TerminalNode + MERGE() antlr.TerminalNode + MIDDLE_NAME() antlr.TerminalNode + MIN() antlr.TerminalNode + MINS_TO_BYPASS_MFA() antlr.TerminalNode + MINS_TO_UNLOCK() antlr.TerminalNode + MINUS_() antlr.TerminalNode + MINUTES() antlr.TerminalNode + MIN_CLUSTER_COUNT() antlr.TerminalNode + MIN_DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode + MODE() antlr.TerminalNode + MODIFIED_AFTER() antlr.TerminalNode + MODIFY() antlr.TerminalNode + MONITOR() antlr.TerminalNode + MONITORS() antlr.TerminalNode + MONTHLY() antlr.TerminalNode + MOVE() antlr.TerminalNode + MULTI_STATEMENT_COUNT() antlr.TerminalNode + MULTI_USER() antlr.TerminalNode + MUST_CHANGE() antlr.TerminalNode + MUST_CHANGE_PASSWORD() antlr.TerminalNode + NAME() antlr.TerminalNode + NCHAR() antlr.TerminalNode + NESTED_TRIGGERS() antlr.TerminalNode + NETWORK() antlr.TerminalNode + NETWORK_POLICY() antlr.TerminalNode + NEVER() antlr.TerminalNode + NEWID() antlr.TerminalNode + NEWNAME() antlr.TerminalNode + NEWSEQUENTIALID() antlr.TerminalNode + NEW_ACCOUNT() antlr.TerminalNode + NEW_BROKER() antlr.TerminalNode + NEW_PASSWORD() antlr.TerminalNode + NEXT() antlr.TerminalNode + NEXTVAL() antlr.TerminalNode + NO() antlr.TerminalNode + NONE() antlr.TerminalNode + NONE_Q() antlr.TerminalNode + NORELY() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + NOTIFICATIONS() antlr.TerminalNode + NOTIFICATION_INTEGRATION() antlr.TerminalNode + NOTIFICATION_PROVIDER() antlr.TerminalNode + NOTIFY() antlr.TerminalNode + NOTIFY_USERS() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + NTILE() antlr.TerminalNode + NULLIF() antlr.TerminalNode + NULLS() antlr.TerminalNode + NULL_() antlr.TerminalNode + NULL_IF() antlr.TerminalNode + NUMANODE() antlr.TerminalNode + NUMBER() antlr.TerminalNode + NUMERIC_ROUNDABORT() antlr.TerminalNode + NVL() antlr.TerminalNode + OAUTH() antlr.TerminalNode + OAUTH_ALLOW_NON_TLS_REDIRECT_URI() antlr.TerminalNode + OAUTH_CLIENT() antlr.TerminalNode + OAUTH_CLIENT_RSA_PUBLIC_KEY() antlr.TerminalNode + OAUTH_ENFORCE_PKCE() antlr.TerminalNode + OAUTH_ISSUE_REFRESH_TOKENS() antlr.TerminalNode + OAUTH_REDIRECT_URI() antlr.TerminalNode + OAUTH_REFRESH_TOKEN_VALIDITY() antlr.TerminalNode + OAUTH_USE_SECONDARY_ROLES() antlr.TerminalNode + OBJECT() antlr.TerminalNode + OBJECT_Q() antlr.TerminalNode + OBJECTS() antlr.TerminalNode + OBJECT_TYPES() antlr.TerminalNode + OFF() antlr.TerminalNode + OFFSET() antlr.TerminalNode + OFFSETS() antlr.TerminalNode + OKTA() antlr.TerminalNode + OKTA_PROVISIONER_Q() antlr.TerminalNode + OKTA_Q() antlr.TerminalNode + OLD() antlr.TerminalNode + OLD_ACCOUNT() antlr.TerminalNode + OLD_PASSWORD() antlr.TerminalNode + OMIT() antlr.TerminalNode + ONE() antlr.TerminalNode + ONLINE() antlr.TerminalNode + ONLY() antlr.TerminalNode + ON_ERROR() antlr.TerminalNode + ON_FAILURE() antlr.TerminalNode + OPEN() antlr.TerminalNode + OPERATE() antlr.TerminalNode + OPERATIONS() antlr.TerminalNode + OPTIMIZATION() antlr.TerminalNode + OPTION() antlr.TerminalNode + ORC() antlr.TerminalNode + ORC_Q() antlr.TerminalNode + ORGADMIN() antlr.TerminalNode + OUTBOUND() antlr.TerminalNode + OUTER() antlr.TerminalNode + OVER() antlr.TerminalNode + OVERRIDE() antlr.TerminalNode + OVERWRITE() antlr.TerminalNode + OWNER() antlr.TerminalNode + OWNERSHIP() antlr.TerminalNode + PAGE() antlr.TerminalNode + PARALLEL() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + PARAM_NODE() antlr.TerminalNode + PARQUET() antlr.TerminalNode + PARQUET_Q() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + PARTITION() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + PARTITION_TYPE() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + PAST() antlr.TerminalNode + PATH_() antlr.TerminalNode + PATTERN() antlr.TerminalNode + PER() antlr.TerminalNode + PERCENT() antlr.TerminalNode + PERCENTILE_CONT() antlr.TerminalNode + PERCENTILE_DISC() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + PERIODIC_DATA_REKEYING() antlr.TerminalNode + PERMISSION_SET() antlr.TerminalNode + PERSISTED() antlr.TerminalNode + PERSIST_SAMPLE_PERCENT() antlr.TerminalNode + PING_FEDERATE() antlr.TerminalNode + PIPE() antlr.TerminalNode + PIPES() antlr.TerminalNode + PIPE_EXECUTION_PAUSED() antlr.TerminalNode + PIVOT() antlr.TerminalNode + PLAN() antlr.TerminalNode + PLATFORM() antlr.TerminalNode + POLICIES() antlr.TerminalNode + POLICY() antlr.TerminalNode + POOL() antlr.TerminalNode + PORT() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + PRECISION() antlr.TerminalNode + PREDICATE() antlr.TerminalNode + PREFIX() antlr.TerminalNode + PRESERVE_SPACE() antlr.TerminalNode + PREVENT_UNLOAD_TO_INLINE_URL() antlr.TerminalNode + PREVENT_UNLOAD_TO_INTERNAL_STAGES() antlr.TerminalNode + PRE_AUTHORIZED_ROLES_LIST() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + PRIMARY_ROLE() antlr.TerminalNode + PRIOR() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + PRIORITY_LEVEL() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + PRIVATE_KEY() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + PROC() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PROCEDURES() antlr.TerminalNode + PROCEDURE_NAME() antlr.TerminalNode + PROCESS() antlr.TerminalNode + PROFILE() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + PROVIDER() antlr.TerminalNode + PROVIDER_KEY_NAME() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + PURGE() antlr.TerminalNode + PUT() antlr.TerminalNode + PYTHON() antlr.TerminalNode + QUERIES() antlr.TerminalNode + QUERY() antlr.TerminalNode + QUERY_ACCELERATION_MAX_SCALE_FACTOR() antlr.TerminalNode + QUERY_TAG() antlr.TerminalNode + QUEUE() antlr.TerminalNode + QUOTED_IDENTIFIERS_IGNORE_CASE() antlr.TerminalNode + RANGE() antlr.TerminalNode + RANK() antlr.TerminalNode + RAW_DEFLATE() antlr.TerminalNode + READ() antlr.TerminalNode + READER() antlr.TerminalNode + READONLY() antlr.TerminalNode + READPAST() antlr.TerminalNode + READTEXT() antlr.TerminalNode + READWRITE() antlr.TerminalNode + READ_COMMITTED_SNAPSHOT() antlr.TerminalNode + READ_ONLY() antlr.TerminalNode + READ_ONLY_ROUTING_LIST() antlr.TerminalNode + READ_WRITE() antlr.TerminalNode + REBUILD() antlr.TerminalNode + RECEIVE() antlr.TerminalNode + RECLUSTER() antlr.TerminalNode + RECOMPILE() antlr.TerminalNode + RECONFIGURE() antlr.TerminalNode + RECORD_DELIMITER() antlr.TerminalNode + RECOVERY() antlr.TerminalNode + RECURSIVE() antlr.TerminalNode + RECURSIVE_TRIGGERS() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + REFERENCE_USAGE() antlr.TerminalNode + REFRESH() antlr.TerminalNode + REFRESH_ON_CREATE() antlr.TerminalNode + REGION() antlr.TerminalNode + REGIONS() antlr.TerminalNode + REGION_GROUP() antlr.TerminalNode + RELATIVE() antlr.TerminalNode + RELY() antlr.TerminalNode + REMOTE() antlr.TerminalNode + REMOTE_PROC_TRANSACTIONS() antlr.TerminalNode + REMOTE_SERVICE_NAME() antlr.TerminalNode + REMOVE() antlr.TerminalNode + RENAME() antlr.TerminalNode + REPEATABLE() antlr.TerminalNode + REPLACE() antlr.TerminalNode + REPLACE_INVALID_CHARACTERS() antlr.TerminalNode + REPLICA() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + REPLICATION_SCHEDULE() antlr.TerminalNode + REQUEST_TRANSLATOR() antlr.TerminalNode + REQUIRED() antlr.TerminalNode + REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION() antlr.TerminalNode + REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION() antlr.TerminalNode + RESET() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + RESOURCES() antlr.TerminalNode + RESOURCE_MONITOR() antlr.TerminalNode + RESPONSE_TRANSLATOR() antlr.TerminalNode + RESTART() antlr.TerminalNode + RESTORE() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + RESTRICTIONS() antlr.TerminalNode + RESULT() antlr.TerminalNode + RESUME() antlr.TerminalNode + RETAINDAYS() antlr.TerminalNode + RETURN() antlr.TerminalNode + RETURNS() antlr.TerminalNode + RETURN_ALL_ERRORS() antlr.TerminalNode + RETURN_ERRORS() antlr.TerminalNode + RETURN_FAILED_ONLY() antlr.TerminalNode + RETURN_N_ROWS() antlr.TerminalNode + RETURN_ROWS() antlr.TerminalNode + REVERSE() antlr.TerminalNode + REVERT() antlr.TerminalNode + REWIND() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROLES() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + ROOT() antlr.TerminalNode + ROWCOUNT() antlr.TerminalNode + ROWGUID() antlr.TerminalNode + ROWLOCK() antlr.TerminalNode + ROWS_PER_RESULTSET() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + RSA_PUBLIC_KEY() antlr.TerminalNode + RTRIM() antlr.TerminalNode + RUN_AS_ROLE() antlr.TerminalNode + SAFE() antlr.TerminalNode + SAFETY() antlr.TerminalNode + SAML_IDENTITY_PROVIDER() antlr.TerminalNode + SAVE_OLD_URL() antlr.TerminalNode + SCALING_POLICY() antlr.TerminalNode + SCHEDULE() antlr.TerminalNode + SCHEDULER() antlr.TerminalNode + SCHEMAS() antlr.TerminalNode + SCHEME() antlr.TerminalNode + SCIM() antlr.TerminalNode + SCIM_CLIENT() antlr.TerminalNode + SCRIPT() antlr.TerminalNode + SEARCH() antlr.TerminalNode + SECONDARY() antlr.TerminalNode + SECONDARY_ONLY() antlr.TerminalNode + SECONDARY_ROLE() antlr.TerminalNode + SECONDS() antlr.TerminalNode + SECRET() antlr.TerminalNode + SECURE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + SECURITYADMIN() antlr.TerminalNode + SEED() antlr.TerminalNode + SELF() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + SEQUENCES() antlr.TerminalNode + SERVER() antlr.TerminalNode + SERVICE() antlr.TerminalNode + SESSION() antlr.TerminalNode + SESSION_IDLE_TIMEOUT_MINS() antlr.TerminalNode + SESSION_POLICY() antlr.TerminalNode + SESSION_UI_IDLE_TIMEOUT_MINS() antlr.TerminalNode + SETS() antlr.TerminalNode + SETUSER() antlr.TerminalNode + SHARE() antlr.TerminalNode + SHARED() antlr.TerminalNode + SHARES() antlr.TerminalNode + SHARE_RESTRICTIONS() antlr.TerminalNode + SHOW() antlr.TerminalNode + SHOWPLAN() antlr.TerminalNode + SHOWPLAN_ALL() antlr.TerminalNode + SHOWPLAN_TEXT() antlr.TerminalNode + SHOWPLAN_XML() antlr.TerminalNode + SHOW_INITIAL_ROWS() antlr.TerminalNode + SIGNATURE() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + SIMULATED_DATA_SHARING_CONSUMER() antlr.TerminalNode + SINGLE_USER() antlr.TerminalNode + SIZE() antlr.TerminalNode + SIZE_LIMIT() antlr.TerminalNode + SKIP_() antlr.TerminalNode + SKIP_BLANK_LINES() antlr.TerminalNode + SKIP_BYTE_ORDER_MARK() antlr.TerminalNode + SKIP_FILE() antlr.TerminalNode + SKIP_FILE_N() antlr.TerminalNode + SKIP_HEADER() antlr.TerminalNode + SMALL() antlr.TerminalNode + SNAPPY() antlr.TerminalNode + SNAPPY_COMPRESSION() antlr.TerminalNode + SOUNDEX() antlr.TerminalNode + SOURCE() antlr.TerminalNode + SOURCE_COMPRESSION() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + SPARSE() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + SPLIT() antlr.TerminalNode + SPLIT_PART() antlr.TerminalNode + SQL() antlr.TerminalNode + SSO_LOGIN_PAGE() antlr.TerminalNode + STAGE() antlr.TerminalNode + STAGES() antlr.TerminalNode + STAGE_COPY_OPTIONS() antlr.TerminalNode + STAGE_FILE_FORMAT() antlr.TerminalNode + STANDARD() antlr.TerminalNode + STANDBY() antlr.TerminalNode + STARTED() antlr.TerminalNode + STARTS() antlr.TerminalNode + START_DATE() antlr.TerminalNode + START_TIMESTAMP() antlr.TerminalNode + STATE() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + STATEMENT_QUEUED_TIMEOUT_IN_SECONDS() antlr.TerminalNode + STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode + STATIC() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + STATS() antlr.TerminalNode + STATS_DATE() antlr.TerminalNode + STATS_STREAM() antlr.TerminalNode + STATUS() antlr.TerminalNode + STATUSONLY() antlr.TerminalNode + STDEV() antlr.TerminalNode + STDEVP() antlr.TerminalNode + STOP() antlr.TerminalNode + STOPLIST() antlr.TerminalNode + STOPPED() antlr.TerminalNode + STORAGE() antlr.TerminalNode + STORAGE_ALLOWED_LOCATIONS() antlr.TerminalNode + STORAGE_AWS_OBJECT_ACL() antlr.TerminalNode + STORAGE_AWS_ROLE_ARN() antlr.TerminalNode + STORAGE_BLOCKED_LOCATIONS() antlr.TerminalNode + STORAGE_INTEGRATION() antlr.TerminalNode + STORAGE_PROVIDER() antlr.TerminalNode + STR() antlr.TerminalNode + STREAM() antlr.TerminalNode + STREAMS() antlr.TerminalNode + STRICT() antlr.TerminalNode + STRICT_JSON_OUTPUT() antlr.TerminalNode + STRING_AGG() antlr.TerminalNode + STRING_ESCAPE() antlr.TerminalNode + STRIP_NULL_VALUES() antlr.TerminalNode + STRIP_OUTER_ARRAY() antlr.TerminalNode + STRIP_OUTER_ELEMENT() antlr.TerminalNode + SUBSTR() antlr.TerminalNode + SUBSTRING() antlr.TerminalNode + SUM() antlr.TerminalNode + SUPPORTED() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + SUSPENDED() antlr.TerminalNode + SUSPEND_IMMEDIATE() antlr.TerminalNode + SUSPEND_TASK_AFTER_NUM_FAILURES() antlr.TerminalNode + SWAP() antlr.TerminalNode + SWITCH() antlr.TerminalNode + SYNC_PASSWORD() antlr.TerminalNode + SYSADMIN() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + SYSTEM_USER() antlr.TerminalNode + TABLEAU_DESKTOP() antlr.TerminalNode + TABLEAU_SERVER() antlr.TerminalNode + TABLES() antlr.TerminalNode + TABLE_FORMAT() antlr.TerminalNode + TABULAR() antlr.TerminalNode + TAG() antlr.TerminalNode + TAGS() antlr.TerminalNode + TARGET() antlr.TerminalNode + TARGET_LAG() antlr.TerminalNode + TASK() antlr.TerminalNode + TASKS() antlr.TerminalNode + TEMP() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + TERSE() antlr.TerminalNode + TEXTSIZE() antlr.TerminalNode + TIES() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMEADD() antlr.TerminalNode + TIMEDIFF() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + TIMER() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TIMESTAMP_FORMAT() antlr.TerminalNode + TIMESTAMP_INPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_LTZ() antlr.TerminalNode + TIMESTAMP_LTZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_NTZ() antlr.TerminalNode + TIMESTAMP_NTZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode + TIMESTAMP_TZ() antlr.TerminalNode + TIMESTAMP_TZ_OUTPUT_FORMAT() antlr.TerminalNode + TIMESTAMPADD() antlr.TerminalNode + TIMESTAMPDIFF() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + TIME_FORMAT() antlr.TerminalNode + TIME_INPUT_FORMAT() antlr.TerminalNode + TIME_OUTPUT_FORMAT() antlr.TerminalNode + TO_BOOLEAN() antlr.TerminalNode + TO_DATE() antlr.TerminalNode + TOP() antlr.TerminalNode + TORN_PAGE_DETECTION() antlr.TerminalNode + TRACKING() antlr.TerminalNode + TRACK_CAUSALITY() antlr.TerminalNode + TRAN() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + TRANSACTIONS() antlr.TerminalNode + TRANSACTION_ABORT_ON_ERROR() antlr.TerminalNode + TRANSACTION_DEFAULT_ISOLATION_LEVEL() antlr.TerminalNode + TRANSACTION_ID() antlr.TerminalNode + TRANSFORM_NOISE_WORDS() antlr.TerminalNode + TRANSIENT() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + TRIM() antlr.TerminalNode + TRIM_SPACE() antlr.TerminalNode + TRIPLE_DES() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + TRUNCATECOLUMNS() antlr.TerminalNode + TRUSTWORTHY() antlr.TerminalNode + TRY() antlr.TerminalNode + TSEQUAL() antlr.TerminalNode + TSQL() antlr.TerminalNode + TWO_DIGIT_CENTURY_START() antlr.TerminalNode + TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode + TYPE() antlr.TerminalNode + TYPEPROPERTY() antlr.TerminalNode + TYPE_ID() antlr.TerminalNode + TYPE_NAME() antlr.TerminalNode + TYPE_WARNING() antlr.TerminalNode + UN() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + UNCHECKED() antlr.TerminalNode + UNCOMMITTED() antlr.TerminalNode + UNDROP() antlr.TerminalNode + UNICODE() antlr.TerminalNode + UNKNOWN() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + UNLOCK() antlr.TerminalNode + UNMASK() antlr.TerminalNode + UNMATCHED() antlr.TerminalNode + UNPIVOT() antlr.TerminalNode + UNSAFE() antlr.TerminalNode + UNSET() antlr.TerminalNode + UNSUPPORTED_DDL_ACTION() antlr.TerminalNode + UOW() antlr.TerminalNode + UPDLOCK() antlr.TerminalNode + UPPER() antlr.TerminalNode + URL() antlr.TerminalNode + USAGE() antlr.TerminalNode + USE() antlr.TerminalNode + USED() antlr.TerminalNode + USER() antlr.TerminalNode + USERADMIN() antlr.TerminalNode + USERS() antlr.TerminalNode + USER_SPECIFIED() antlr.TerminalNode + USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE() antlr.TerminalNode + USER_TASK_TIMEOUT_MS() antlr.TerminalNode + USE_ANY_ROLE() antlr.TerminalNode + USE_CACHED_RESULT() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + VALIDATION() antlr.TerminalNode + VALIDATION_MODE() antlr.TerminalNode + VALID_XML() antlr.TerminalNode + VALUE() antlr.TerminalNode + VAR() antlr.TerminalNode + VARIABLES() antlr.TerminalNode + VARP() antlr.TerminalNode + VARYING() antlr.TerminalNode + VERSION() antlr.TerminalNode + VIEWS() antlr.TerminalNode + VIEW_METADATA() antlr.TerminalNode + VISIBILITY() antlr.TerminalNode + VOLATILE() antlr.TerminalNode + WAIT() antlr.TerminalNode + WAREHOUSE() antlr.TerminalNode + WAREHOUSES() antlr.TerminalNode + WAREHOUSE_SIZE() antlr.TerminalNode + WEEKLY() antlr.TerminalNode + WEEK_OF_YEAR_POLICY() antlr.TerminalNode + WEEK_START() antlr.TerminalNode + WELL_FORMED_XML() antlr.TerminalNode + WITHIN() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WITHOUT_ARRAY_WRAPPER() antlr.TerminalNode + WORK() antlr.TerminalNode + WORKLOAD() antlr.TerminalNode + WRITE() antlr.TerminalNode + XLARGE() antlr.TerminalNode + XLOCK() antlr.TerminalNode + XML() antlr.TerminalNode + XML_Q() antlr.TerminalNode + XSMALL() antlr.TerminalNode + XXLARGE() antlr.TerminalNode + XXXLARGE() antlr.TerminalNode + YEARLY() antlr.TerminalNode + ZSTD() antlr.TerminalNode + ARRAY() antlr.TerminalNode + ARRAY_Q() antlr.TerminalNode + BIGINT() antlr.TerminalNode + BINARY() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + BYTEINT() antlr.TerminalNode + CHAR_VARYING() antlr.TerminalNode + DATE() antlr.TerminalNode + DATETIME() antlr.TerminalNode + DECIMAL_() antlr.TerminalNode + FLOAT_() antlr.TerminalNode + GEOGRAPHY() antlr.TerminalNode + GEOMETRY() antlr.TerminalNode + INTEGER() antlr.TerminalNode + NCHAR_VARYING() antlr.TerminalNode + NUMERIC() antlr.TerminalNode + NVARCHAR() antlr.TerminalNode + REAL_() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + STRING_() antlr.TerminalNode + TEXT() antlr.TerminalNode + TINYINT() antlr.TerminalNode + VARBINARY() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + VARIANT() antlr.TerminalNode + LISTAGG() antlr.TerminalNode + DUMMY() antlr.TerminalNode + + // IsSupplement_non_reserved_wordsContext differentiates from other interfaces. + IsSupplement_non_reserved_wordsContext() +} + +type Supplement_non_reserved_wordsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplement_non_reserved_wordsContext() *Supplement_non_reserved_wordsContext { + var p = new(Supplement_non_reserved_wordsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_supplement_non_reserved_words + return p +} + +func InitEmptySupplement_non_reserved_wordsContext(p *Supplement_non_reserved_wordsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = SnowflakeParserRULE_supplement_non_reserved_words +} + +func (*Supplement_non_reserved_wordsContext) IsSupplement_non_reserved_wordsContext() {} + +func NewSupplement_non_reserved_wordsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplement_non_reserved_wordsContext { + var p = new(Supplement_non_reserved_wordsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = SnowflakeParserRULE_supplement_non_reserved_words + + return p +} + +func (s *Supplement_non_reserved_wordsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplement_non_reserved_wordsContext) AAD_PROVISIONER_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAAD_PROVISIONER_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ABORT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ABORT_AFTER_WAIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT_AFTER_WAIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ABORT_DETACHED_QUERY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT_DETACHED_QUERY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ABORT_STATEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABORT_STATEMENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ABSENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABSENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ABSOLUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserABSOLUTE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ACCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCESS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ACCOUNTADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTADMIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACCOUNTS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ACTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ACTIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserACTIVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADMINISTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ADMIN_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADMIN_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ADMIN_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserADMIN_PASSWORD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AFTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAFTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAGGREGATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALERTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALERTS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOWED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOWED_ACCOUNTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_ACCOUNTS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOWED_DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_DATABASES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOWED_INTEGRATION_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_INTEGRATION_TYPES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOWED_IP_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_IP_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOWED_SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_SHARES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOWED_VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOWED_VALUES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOW_CLIENT_MFA_CACHING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_CLIENT_MFA_CACHING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOW_CONNECTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_CONNECTIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOW_DUPLICATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_DUPLICATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOW_ID_TOKEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_ID_TOKEN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOW_MULTIPLE_EVENT_LOSS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_MULTIPLE_EVENT_LOSS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOW_OVERLAPPING_EXECUTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_OVERLAPPING_EXECUTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALLOW_SINGLE_EVENT_LOSS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALLOW_SINGLE_EVENT_LOSS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserALWAYS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ANONYMOUS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserANONYMOUS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ANSI_DEFAULTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserANSI_DEFAULTS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) API() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI, 0) +} + +func (s *Supplement_non_reserved_wordsContext) API_ALLOWED_PREFIXES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_ALLOWED_PREFIXES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) API_AWS_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_AWS_ROLE_ARN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) API_BLOCKED_PREFIXES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_BLOCKED_PREFIXES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) API_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_INTEGRATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) API_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_KEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) API_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPI_PROVIDER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) APPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPPEND, 0) +} + +func (s *Supplement_non_reserved_wordsContext) APPEND_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPPEND_ONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPPLICATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) APPLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPPLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) APP_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAPP_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ASC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserASC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ATTACH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserATTACH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AT_KEYWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAT_KEYWORD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTHORIZATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTHORIZATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTHORIZATIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTO_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTOCOMMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTOCOMMIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTOCOMMIT_API_SUPPORTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTOCOMMIT_API_SUPPORTED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTOINCREMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTOINCREMENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTO_COMPRESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_COMPRESS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTO_DETECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_DETECT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTO_INGEST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_INGEST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTO_REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_REFRESH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTO_RESUME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_RESUME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AUTO_SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAUTO_SUSPEND, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AVG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AVRO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVRO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AVRO_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAVRO_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AWS_KEY_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_KEY_ID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AWS_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_ROLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AWS_SECRET_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SECRET_KEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AWS_SNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AWS_SNS_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS_ROLE_ARN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AWS_SNS_TOPIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS_TOPIC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AWS_SNS_TOPIC_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_SNS_TOPIC_ARN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AWS_TOKEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAWS_TOKEN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AZURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AZURE_AD_APPLICATION_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_AD_APPLICATION_ID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AZURE_EVENT_GRID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_EVENT_GRID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AZURE_EVENT_GRID_TOPIC_ENDPOINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_EVENT_GRID_TOPIC_ENDPOINT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AZURE_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AZURE_SAS_TOKEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_SAS_TOKEN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AZURE_STORAGE_QUEUE_PRIMARY_URI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_STORAGE_QUEUE_PRIMARY_URI, 0) +} + +func (s *Supplement_non_reserved_wordsContext) AZURE_TENANT_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserAZURE_TENANT_ID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BEFORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBEFORE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BEGIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBEGIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BERNOULLI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBERNOULLI, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BINARY_AS_TEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_AS_TEXT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BINARY_CHECKSUM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_CHECKSUM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BINARY_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BINARY_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_INPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BINARY_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BINDING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINDING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BLOCK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBLOCK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BLOCKED_IP_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBLOCKED_IP_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BLOCKED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBLOCKED_ROLES_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BODY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBODY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BOTH_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBOTH_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BROTLI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBROTLI, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BUSINESS_CRITICAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBUSINESS_CRITICAL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CACHE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCACHE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCALL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CALLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCALLED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CALLER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCALLER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CASCADE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCASCADE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CASE_INSENSITIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCASE_INSENSITIVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CASE_SENSITIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCASE_SENSITIVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CATCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCATCH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCERTIFICATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHANGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHANGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHANGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHANGES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHANGETABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHANGETABLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHANGE_RETENTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHANGE_RETENTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHANGE_TRACKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHANGE_TRACKING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHAR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHARACTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHARINDEX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHARINDEX, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHECKSUM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHECKSUM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHECKSUM_AGG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHECKSUM_AGG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHECK_EXPIRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHECK_EXPIRATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHECK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHECK_POLICY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLASSIFIER_FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLASSIFIER_FUNCTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLEANUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLEANUP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_ENCRYPTION_KEY_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_ENCRYPTION_KEY_SIZE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_MEMORY_LIMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_MEMORY_LIMIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_METADATA_REQUEST_USE_CONNECTION_CTX, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_METADATA_USE_SESSION_DATABASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_METADATA_USE_SESSION_DATABASE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_PREFETCH_THREADS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_PREFETCH_THREADS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_RESULT_CHUNK_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_RESULT_CHUNK_SIZE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_RESULT_COLUMN_CASE_INSENSITIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_RESULT_COLUMN_CASE_INSENSITIVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_SESSION_KEEP_ALIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_SESSION_KEEP_ALIVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLIENT_TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLIENT_TIMESTAMP_TYPE_MAPPING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLONE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLOSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLOSE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLUSTERED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTERED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCLUSTERING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COALESCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOALESCE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COLLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLLATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COLLECTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLLECTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOLUMNS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COL_LENGTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOL_LENGTH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COL_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOL_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COMMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COMMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMMITTED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMPRESS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COMPRESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOMPRESSION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONCAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONCAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONCAT_NULL_YIELDS_NULL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONCAT_NULL_YIELDS_NULL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONCAT_WS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONCAT_WS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONDITION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONFIGURATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONFIGURATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONNECTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONNECTIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONTAINMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTAINMENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONTAINS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTAINS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONTENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTEXT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONTEXT_HEADERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTEXT_HEADERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONTEXT_INFO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTEXT_INFO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTINUE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONTROL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONTROL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CONVERSATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCONVERSATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COOKIE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOOKIE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COPY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COPY_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY_ONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COPY_OPTIONS_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOPY_OPTIONS_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOUNT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) COUNT_BIG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCOUNT_BIG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CREDENTIALS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREDENTIALS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CREDIT_QUOTA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCREDIT_QUOTA, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CSV() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCSV, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CSV_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCSV_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CUBE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCUBE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCUME_DIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CURSOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCURSOR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CUSTOM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCUSTOM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DAILY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDAILY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATABASES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATABASES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATEADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATEADD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATEDIFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATEDIFF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATENAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATEPART() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATEPART, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATE_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_INPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATE_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATE_PART() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE_PART, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDAYS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DAYS_TO_EXPIRY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDAYS_TO_EXPIRY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DECLARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDECLARE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFAULT_DDL_COLLATION_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_DDL_COLLATION_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFAULT_NAMESPACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_NAMESPACE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFAULT_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_ROLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFAULT_WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFAULT_WAREHOUSE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFERRABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFERRABLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFERRED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFINE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFINE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFINITION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DEFLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDEFLATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DELEGATED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELEGATED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DELTA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDELTA, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDENSE_RANK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DESC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDESC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DESCRIBE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDESCRIBE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DIRECTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDIRECTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDIRECTORY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DISABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DISABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DISABLE_AUTO_CONVERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE_AUTO_CONVERT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DISABLE_SNOWFLAKE_DATA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISABLE_SNOWFLAKE_DATA, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DISK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DISPLAY_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDISPLAY_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DOWNSTREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOWNSTREAM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDOUBLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDYNAMIC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ECONOMY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserECONOMY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EDITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEDITION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EMAIL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEMAIL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EMPTY_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEMPTY_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EMPTY_FIELD_AS_NULL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEMPTY_FIELD_AS_NULL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENABLED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENABLE_FOR_PRIVILEGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_FOR_PRIVILEGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENABLE_INTERNAL_STAGES_PRIVATELINK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_INTERNAL_STAGES_PRIVATELINK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENABLE_OCTAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_OCTAL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENABLE_QUERY_ACCELERATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_QUERY_ACCELERATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENCODING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENCODING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENCRYPTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) END() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEND, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENDPOINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENDPOINT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) END_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEND_TIMESTAMP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENFORCED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENFORCE_LENGTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENFORCE_LENGTH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENFORCE_SESSION_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENFORCE_SESSION_POLICY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ENTERPRISE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserENTERPRISE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EQUALITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEQUALITY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ERROR_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_INTEGRATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ERROR_ON_COLUMN_COUNT_MISMATCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_ON_COLUMN_COUNT_MISMATCH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ERROR_ON_NONDETERMINISTIC_MERGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_ON_NONDETERMINISTIC_MERGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ERROR_ON_NONDETERMINISTIC_UPDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserERROR_ON_NONDETERMINISTIC_UPDATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserESCAPE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ESCAPE_UNENCLOSED_FIELD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserESCAPE_UNENCLOSED_FIELD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXCEPT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXCHANGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXECUTE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXECUTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXECUTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXPAND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXPAND, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXPIRY_DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXPIRY_DATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXPLAIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXPLICIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXPLICIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ADD_PRIVILEGED_ROLES_TO_BLOCKED_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_ALLOWED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ALLOWED_ROLES_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_ANY_ROLE_MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ANY_ROLE_MODE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_AUDIENCE_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_AUDIENCE_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_BLOCKED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_BLOCKED_ROLES_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_ISSUER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_ISSUER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_JWS_KEYS_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_JWS_KEYS_URL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_RSA_PUBLIC_KEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_SCOPE_DELIMITER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_SCOPE_DELIMITER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_SNOWFLAKE_USER_MAPPING_ATTRIBUTE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_TOKEN_USER_MAPPING_CLAIM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_OAUTH_TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_OAUTH_TYPE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) EXTERNAL_STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserEXTERNAL_STAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FAILOVER_MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAILOVER_MODE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FAIL_OPERATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFAIL_OPERATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FETCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFETCH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FIELD_DELIMITER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIELD_DELIMITER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FIELD_OPTIONALLY_ENCLOSED_BY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIELD_OPTIONALLY_ENCLOSED_BY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FILES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FILE_EXTENSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE_EXTENSION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FILE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILE_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FILTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFILTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FIRST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIRST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FIRST_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFIRST_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FLATTEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFLATTEN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FORCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORCE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFOREIGN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FORMATS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMATS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FORMAT_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFORMAT_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FREQUENCY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFREQUENCY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUNCTIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FUTURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFUTURE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GCP_PUBSUB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCP_PUBSUB, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GCP_PUBSUB_SUBSCRIPTION_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCP_PUBSUB_SUBSCRIPTION_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GCP_PUBSUB_TOPIC_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCP_PUBSUB_TOPIC_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GCS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGCS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GENERIC_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGENERIC_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GENERIC_SCIM_PROVISIONER_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGENERIC_SCIM_PROVISIONER_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GEO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GEOGRAPHY_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEOGRAPHY_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GEOMETRY_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEOMETRY_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GET_FILESTREAM_TRANSACTION_CONTEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGET_FILESTREAM_TRANSACTION_CONTEXT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGLOBAL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GOOGLE_AUDIENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGOOGLE_AUDIENCE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GOTO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGOTO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GRANTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGRANTS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GROUPING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUPING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GROUPING_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUPING_ID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GROUPS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGROUPS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GZIP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGZIP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) HEADER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHEADER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) HEADERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHEADERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) HEX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHEX, 0) +} + +func (s *Supplement_non_reserved_wordsContext) HIERARCHYID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHIERARCHYID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) HIGH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHIGH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) HISTORY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHISTORY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) HOURS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserHOURS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIDENTITY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIFF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IFNULL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIFNULL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IGNORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IGNORE_CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE_CONSTRAINTS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IGNORE_DUP_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE_DUP_KEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE_NONCLUSTERED_COLUMNSTORE_INDEX, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IGNORE_TRIGGERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIGNORE_TRIGGERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMEDIATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IMMEDIATELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMEDIATELY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMMUTABLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IMPLICIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMPLICIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IMPORT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMPORT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) IMPORTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserIMPORTED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INDEX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINDEX, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INFORMATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINFORMATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INITIALLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINITIALLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INITIALLY_SUSPENDED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINITIALLY_SUSPENDED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INITIAL_REPLICATION_SIZE_LIMIT_IN_TB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINITIAL_REPLICATION_SIZE_LIMIT_IN_TB, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INPUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINPUT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INSERT_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINSERT_ONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINSTEAD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INTEGRATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGRATIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ISNULL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserISNULL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ISNUMERIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserISNUMERIC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserISOLATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) JAVASCRIPT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJAVASCRIPT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) JDBC_TREAT_DECIMAL_AS_INT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJDBC_TREAT_DECIMAL_AS_INT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJDBC_TREAT_TIMESTAMP_NTZ_AS_UTC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) JDBC_USE_SESSION_TIMEZONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJDBC_USE_SESSION_TIMEZONE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) JSON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON, 0) +} + +func (s *Supplement_non_reserved_wordsContext) JSON_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) JSON_INDENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJSON_INDENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) JS_TREAT_INTEGER_AS_BIGINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserJS_TREAT_INTEGER_AS_BIGINT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) KB() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKB, 0) +} + +func (s *Supplement_non_reserved_wordsContext) KEEP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEEP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) KEYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEYS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) KEYSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKEYSET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) KMS_KEY_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserKMS_KEY_ID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLANGUAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLARGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LAST_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LAST_QUERY_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST_QUERY_ID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLAST_VALUE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LEAD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLEAD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLEN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LENGTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLENGTH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLEVEL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LIMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIMIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LINENO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLINENO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LISTENER_IP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLISTENER_IP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LISTENER_PORT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLISTENER_PORT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LISTING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLISTING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOAD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOAD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOCAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCAL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOCAL_SERVICE_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCAL_SERVICE_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOCATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOCKS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCKS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOCK_TIMEOUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOCK_TIMEOUT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOGIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOGIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOGIN_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOGIN_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOOKER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOOKER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOW, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LOWER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLOWER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LTRIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLTRIM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LZO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLZO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MANAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMANAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MANAGED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMANAGED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MASKED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MASKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASKING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MASTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MASTER_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMASTER_KEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MATCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MATCHED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCHED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MATCHES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCHES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MATCH_BY_COLUMN_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCH_BY_COLUMN_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MATCH_RECOGNIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATCH_RECOGNIZE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMATERIALIZED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MAX_BATCH_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_BATCH_ROWS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MAX_CLUSTER_COUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_CLUSTER_COUNT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MAX_CONCURRENCY_LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_CONCURRENCY_LEVEL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MAX_DATA_EXTENSION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_DATA_EXTENSION_TIME_IN_DAYS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MAX_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMAX_SIZE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MEASURES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMEASURES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMEDIUM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MEMOIZABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMEMOIZABLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MERGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMERGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MIDDLE_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMIDDLE_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MINS_TO_BYPASS_MFA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINS_TO_BYPASS_MFA, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MINS_TO_UNLOCK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINS_TO_UNLOCK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MINUS_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINUS_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MINUTES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMINUTES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MIN_CLUSTER_COUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMIN_CLUSTER_COUNT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MIN_DATA_RETENTION_TIME_IN_DAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMIN_DATA_RETENTION_TIME_IN_DAYS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MODIFIED_AFTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODIFIED_AFTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MODIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMODIFY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITOR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MONITORS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONITORS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MONTHLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMONTHLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMOVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MULTI_STATEMENT_COUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMULTI_STATEMENT_COUNT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MULTI_USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMULTI_USER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MUST_CHANGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMUST_CHANGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) MUST_CHANGE_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserMUST_CHANGE_PASSWORD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NCHAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNCHAR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NESTED_TRIGGERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNESTED_TRIGGERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NETWORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NETWORK_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNETWORK_POLICY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEVER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEWID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEWID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEWNAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEWNAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEWSEQUENTIALID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEWSEQUENTIALID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEW_ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEW_ACCOUNT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEW_BROKER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEW_BROKER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEW_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEW_PASSWORD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEXT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NEXTVAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNEXTVAL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NO() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNO, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NONE_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNONE_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NORELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNORELY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NOTIFICATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NOTIFICATION_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION_INTEGRATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NOTIFICATION_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFICATION_PROVIDER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NOTIFY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NOTIFY_USERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOTIFY_USERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNOVALIDATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NTILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNTILE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NULLIF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULLIF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NULLS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULLS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NULL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NULL_IF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNULL_IF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NUMANODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNUMANODE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NUMBER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNUMBER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NUMERIC_ROUNDABORT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNUMERIC_ROUNDABORT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NVL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNVL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH_ALLOW_NON_TLS_REDIRECT_URI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_ALLOW_NON_TLS_REDIRECT_URI, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH_CLIENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_CLIENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH_CLIENT_RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_CLIENT_RSA_PUBLIC_KEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH_ENFORCE_PKCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_ENFORCE_PKCE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH_ISSUE_REFRESH_TOKENS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_ISSUE_REFRESH_TOKENS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH_REDIRECT_URI() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_REDIRECT_URI, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH_REFRESH_TOKEN_VALIDITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_REFRESH_TOKEN_VALIDITY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OAUTH_USE_SECONDARY_ROLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOAUTH_USE_SECONDARY_ROLES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OBJECT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OBJECT_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OBJECTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECTS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OBJECT_TYPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOBJECT_TYPES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OFFSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFFSET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OFFSETS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOFFSETS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OKTA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOKTA, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OKTA_PROVISIONER_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOKTA_PROVISIONER_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OKTA_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOKTA_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OLD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOLD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OLD_ACCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOLD_ACCOUNT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OLD_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOLD_PASSWORD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOMIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserONE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ONLINE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserONLINE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ON_ERROR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON_ERROR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ON_FAILURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserON_FAILURE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OPEN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPEN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OPERATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPERATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OPERATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPERATIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OPTIMIZATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPTIMIZATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OPTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOPTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ORC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ORC_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORC_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ORGADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserORGADMIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OUTBOUND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOUTBOUND, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OUTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOUTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOVER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOVERRIDE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OVERWRITE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOVERWRITE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OWNER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOWNER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) OWNERSHIP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserOWNERSHIP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARALLEL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARAMETERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARAM_NODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARAM_NODE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARQUET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARQUET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARQUET_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARQUET_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARTIAL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARTITION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARTITIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PARTITION_TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPARTITION_TYPE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPASSWORD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPAST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PATH_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPATH_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PATTERN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPATTERN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PERCENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERCENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PERCENTILE_CONT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERCENTILE_CONT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PERCENTILE_DISC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERCENTILE_DISC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERCENT_RANK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PERIODIC_DATA_REKEYING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERIODIC_DATA_REKEYING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PERMISSION_SET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERMISSION_SET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PERSISTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERSISTED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PERSIST_SAMPLE_PERCENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPERSIST_SAMPLE_PERCENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PING_FEDERATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPING_FEDERATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PIPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PIPES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PIPE_EXECUTION_PAUSED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIPE_EXECUTION_PAUSED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PIVOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPIVOT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PLAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPLAN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PLATFORM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPLATFORM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) POLICIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICIES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOLICY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) POOL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPOOL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PORT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPORT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRECEDING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRECISION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRECISION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PREDICATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREDICATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PREFIX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREFIX, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRESERVE_SPACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRESERVE_SPACE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PREVENT_UNLOAD_TO_INLINE_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREVENT_UNLOAD_TO_INLINE_URL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PREVENT_UNLOAD_TO_INTERNAL_STAGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPREVENT_UNLOAD_TO_INTERNAL_STAGES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRE_AUTHORIZED_ROLES_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRE_AUTHORIZED_ROLES_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRIMARY_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIMARY_ROLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRIOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIOR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIORITY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRIORITY_LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIORITY_LEVEL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIVATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRIVATE_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIVATE_KEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPRIVILEGES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROCEDURES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROCEDURE_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCEDURE_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROCESS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROCESS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROFILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROFILE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROPERTY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROVIDER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PROVIDER_KEY_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPROVIDER_KEY_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPUBLIC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PURGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPURGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPUT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) PYTHON() antlr.TerminalNode { + return s.GetToken(SnowflakeParserPYTHON, 0) +} + +func (s *Supplement_non_reserved_wordsContext) QUERIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERIES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) QUERY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) QUERY_ACCELERATION_MAX_SCALE_FACTOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERY_ACCELERATION_MAX_SCALE_FACTOR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) QUERY_TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUERY_TAG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) QUEUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUEUE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) QUOTED_IDENTIFIERS_IGNORE_CASE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserQUOTED_IDENTIFIERS_IGNORE_CASE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RANGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRANGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RANK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRANK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RAW_DEFLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRAW_DEFLATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREADER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREADONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READPAST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREADPAST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READTEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREADTEXT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READWRITE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREADWRITE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READ_COMMITTED_SNAPSHOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAD_COMMITTED_SNAPSHOT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READ_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAD_ONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READ_ONLY_ROUTING_LIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAD_ONLY_ROUTING_LIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) READ_WRITE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAD_WRITE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REBUILD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREBUILD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RECEIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECEIVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RECLUSTER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECLUSTER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RECOMPILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECOMPILE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RECONFIGURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECONFIGURE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RECORD_DELIMITER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECORD_DELIMITER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RECOVERY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECOVERY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RECURSIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECURSIVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RECURSIVE_TRIGGERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRECURSIVE_TRIGGERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFERENCES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REFERENCE_USAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFERENCE_USAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REFRESH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REFRESH_ON_CREATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREFRESH_ON_CREATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REGION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREGION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REGIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREGIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REGION_GROUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREGION_GROUP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RELATIVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRELATIVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RELY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRELY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REMOTE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOTE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REMOTE_PROC_TRANSACTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOTE_PROC_TRANSACTIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REMOTE_SERVICE_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOTE_SERVICE_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REMOVE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREMOVE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RENAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRENAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REPEATABLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPEATABLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REPLACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLACE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REPLACE_INVALID_CHARACTERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLACE_INVALID_CHARACTERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REPLICA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICA, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REPLICATION_SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREPLICATION_SCHEDULE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REQUEST_TRANSLATOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUEST_TRANSLATOR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REQUIRED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUIRED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_CREATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREQUIRE_STORAGE_INTEGRATION_FOR_STAGE_OPERATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESOURCES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESOURCE_MONITOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESOURCE_MONITOR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESPONSE_TRANSLATOR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESPONSE_TRANSLATOR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESTART() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESTART, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESTORE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESTORE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESTRICT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESTRICTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESTRICTIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESULT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RESUME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRESUME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RETAINDAYS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETAINDAYS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RETURN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RETURNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURNS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RETURN_ALL_ERRORS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_ALL_ERRORS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RETURN_ERRORS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_ERRORS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RETURN_FAILED_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_FAILED_ONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RETURN_N_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_N_ROWS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RETURN_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRETURN_ROWS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REVERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREVERSE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REVERT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREVERT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REWIND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREWIND, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLLBACK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROLLUP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROOT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROWCOUNT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWCOUNT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROWGUID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWGUID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROWLOCK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWLOCK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROWS_PER_RESULTSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROWS_PER_RESULTSET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserROW_NUMBER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RSA_PUBLIC_KEY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRSA_PUBLIC_KEY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RTRIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRTRIM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) RUN_AS_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserRUN_AS_ROLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SAFE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAFE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SAFETY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAFETY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SAML_IDENTITY_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAML_IDENTITY_PROVIDER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SAVE_OLD_URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSAVE_OLD_URL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SCALING_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCALING_POLICY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SCHEDULE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEDULE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SCHEDULER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEDULER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SCHEMAS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEMAS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SCHEME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCHEME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SCIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCIM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SCIM_CLIENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCIM_CLIENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SCRIPT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSCRIPT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SEARCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEARCH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SECONDARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECONDARY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SECONDARY_ONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECONDARY_ONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SECONDARY_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECONDARY_ROLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECONDS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SECRET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECRET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SECURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SECURITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SECURITYADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSECURITYADMIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SEED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SELF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSELF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SEQUENCES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSEQUENCES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SERVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSERVER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SERVICE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSERVICE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SESSION_IDLE_TIMEOUT_MINS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_IDLE_TIMEOUT_MINS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SESSION_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_POLICY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SESSION_UI_IDLE_TIMEOUT_MINS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSESSION_UI_IDLE_TIMEOUT_MINS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SETS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSETS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SETUSER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSETUSER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHARE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHARED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHARES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHARE_RESTRICTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHARE_RESTRICTIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHOWPLAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOWPLAN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHOWPLAN_ALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOWPLAN_ALL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHOWPLAN_TEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOWPLAN_TEXT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHOWPLAN_XML() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOWPLAN_XML, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SHOW_INITIAL_ROWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSHOW_INITIAL_ROWS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SIGNATURE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIGNATURE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIMPLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SIMULATED_DATA_SHARING_CONSUMER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIMULATED_DATA_SHARING_CONSUMER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SINGLE_USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSINGLE_USER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIZE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SIZE_LIMIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSIZE_LIMIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SKIP_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SKIP_BLANK_LINES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_BLANK_LINES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SKIP_BYTE_ORDER_MARK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_BYTE_ORDER_MARK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SKIP_FILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_FILE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SKIP_FILE_N() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_FILE_N, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SKIP_HEADER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSKIP_HEADER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SMALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSMALL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SNAPPY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSNAPPY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SNAPPY_COMPRESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSNAPPY_COMPRESSION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SOUNDEX() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSOUNDEX, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SOURCE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSOURCE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SOURCE_COMPRESSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSOURCE_COMPRESSION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSPACE_KEYWORD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SPARSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSPARSE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSPECIFICATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SPLIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSPLIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SPLIT_PART() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSPLIT_PART, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SQL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSQL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SSO_LOGIN_PAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSSO_LOGIN_PAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STAGES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STAGE_COPY_OPTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE_COPY_OPTIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STAGE_FILE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTAGE_FILE_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STANDARD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTANDARD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STANDBY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTANDBY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STARTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTARTED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STARTS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTARTS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) START_DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTART_DATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) START_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTART_TIMESTAMP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATEMENT_QUEUED_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_QUEUED_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATEMENT_TIMEOUT_IN_SECONDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATEMENT_TIMEOUT_IN_SECONDS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATIC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATISTICS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATS_DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATS_DATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATS_STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATS_STREAM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATUS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATUS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STATUSONLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTATUSONLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STDEV() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTDEV, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STDEVP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTDEVP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STOP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTOP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STOPLIST() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTOPLIST, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STOPPED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTOPPED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STORAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STORAGE_ALLOWED_LOCATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_ALLOWED_LOCATIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STORAGE_AWS_OBJECT_ACL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_AWS_OBJECT_ACL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STORAGE_AWS_ROLE_ARN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_AWS_ROLE_ARN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STORAGE_BLOCKED_LOCATIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_BLOCKED_LOCATIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STORAGE_INTEGRATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_INTEGRATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STORAGE_PROVIDER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTORAGE_PROVIDER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STREAM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STREAMS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTREAMS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STRICT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRICT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STRICT_JSON_OUTPUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRICT_JSON_OUTPUT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STRING_AGG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING_AGG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STRING_ESCAPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING_ESCAPE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STRIP_NULL_VALUES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRIP_NULL_VALUES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STRIP_OUTER_ARRAY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRIP_OUTER_ARRAY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STRIP_OUTER_ELEMENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRIP_OUTER_ELEMENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUBSTR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SUBSTRING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUBSTRING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SUM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SUPPORTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUPPORTED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SUSPENDED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPENDED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SUSPEND_IMMEDIATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND_IMMEDIATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SUSPEND_TASK_AFTER_NUM_FAILURES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSUSPEND_TASK_AFTER_NUM_FAILURES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SWAP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSWAP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SWITCH() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSWITCH, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SYNC_PASSWORD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYNC_PASSWORD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SYSADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYSADMIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYSTEM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SYSTEM_USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSYSTEM_USER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TABLEAU_DESKTOP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLEAU_DESKTOP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TABLEAU_SERVER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLEAU_SERVER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TABLE_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABLE_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TABULAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTABULAR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TAGS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTAGS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TARGET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTARGET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TARGET_LAG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTARGET_LAG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TASKS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTASKS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TEMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEMP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEMPORARY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TERSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTERSE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TEXTSIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEXTSIZE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMEADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEADD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMEDIFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEDIFF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEOUT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_INPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_LTZ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_LTZ, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_LTZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_LTZ_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_NTZ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_NTZ, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_NTZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_NTZ_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_TYPE_MAPPING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_TYPE_MAPPING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_TZ() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_TZ, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMP_TZ_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMP_TZ_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMPADD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMPADD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMESTAMPDIFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMESTAMPDIFF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIMEZONE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIME_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIME_INPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME_INPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TIME_OUTPUT_FORMAT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTIME_OUTPUT_FORMAT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TO_BOOLEAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO_BOOLEAN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TO_DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTO_DATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TOP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTOP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TORN_PAGE_DETECTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTORN_PAGE_DETECTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRACKING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRACKING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRACK_CAUSALITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRACK_CAUSALITY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRAN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRANSACTIONS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTIONS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRANSACTION_ABORT_ON_ERROR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTION_ABORT_ON_ERROR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRANSACTION_DEFAULT_ISOLATION_LEVEL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTION_DEFAULT_ISOLATION_LEVEL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRANSACTION_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSACTION_ID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRANSFORM_NOISE_WORDS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSFORM_NOISE_WORDS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRANSIENT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSIENT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRANSLATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRIGGERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRIM() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRIM, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRIM_SPACE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRIM_SPACE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRIPLE_DES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRIPLE_DES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUNCATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRUNCATECOLUMNS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUNCATECOLUMNS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRUSTWORTHY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRUSTWORTHY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TRY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTRY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TSEQUAL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTSEQUAL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TSQL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTSQL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TWO_DIGIT_CENTURY_START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTWO_DIGIT_CENTURY_START, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TWO_DIGIT_YEAR_CUTOFF() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTWO_DIGIT_YEAR_CUTOFF, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TYPE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TYPEPROPERTY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPEPROPERTY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TYPE_ID() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE_ID, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TYPE_NAME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE_NAME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TYPE_WARNING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTYPE_WARNING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNBOUNDED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNCHECKED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNCHECKED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNCOMMITTED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNCOMMITTED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNDROP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNDROP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNICODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNICODE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNKNOWN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNKNOWN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNLIMITED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNLOCK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNMASK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNMASK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNMATCHED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNMATCHED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNPIVOT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNPIVOT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNSAFE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSAFE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNSET() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSET, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UNSUPPORTED_DDL_ACTION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUNSUPPORTED_DDL_ACTION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UOW() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUOW, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UPDLOCK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUPDLOCK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) UPPER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUPPER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) URL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserURL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USAGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSAGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USERADMIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSERADMIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USERS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSERS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USER_SPECIFIED() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_SPECIFIED, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USER_TASK_TIMEOUT_MS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSER_TASK_TIMEOUT_MS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USE_ANY_ROLE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE_ANY_ROLE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) USE_CACHED_RESULT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserUSE_CACHED_RESULT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALIDATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALIDATION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VALIDATION_MODE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALIDATION_MODE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VALID_XML() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALID_XML, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VALUE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVALUE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVAR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VARIABLES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARIABLES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VARP() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARP, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VARYING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARYING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VERSION() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVERSION, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VIEWS() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEWS, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VIEW_METADATA() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVIEW_METADATA, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VISIBILITY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVISIBILITY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VOLATILE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVOLATILE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WAIT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAIT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WAREHOUSE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WAREHOUSES() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSES, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WAREHOUSE_SIZE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWAREHOUSE_SIZE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WEEKLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWEEKLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WEEK_OF_YEAR_POLICY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWEEK_OF_YEAR_POLICY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WEEK_START() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWEEK_START, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WELL_FORMED_XML() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWELL_FORMED_XML, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WITHIN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITHIN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITHOUT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WITHOUT_ARRAY_WRAPPER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWITHOUT_ARRAY_WRAPPER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WORK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWORK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WORKLOAD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWORKLOAD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) WRITE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserWRITE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) XLARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXLARGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) XLOCK() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXLOCK, 0) +} + +func (s *Supplement_non_reserved_wordsContext) XML() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXML, 0) +} + +func (s *Supplement_non_reserved_wordsContext) XML_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXML_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) XSMALL() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXSMALL, 0) +} + +func (s *Supplement_non_reserved_wordsContext) XXLARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXXLARGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) XXXLARGE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserXXXLARGE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) YEARLY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserYEARLY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ZSTD() antlr.TerminalNode { + return s.GetToken(SnowflakeParserZSTD, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ARRAY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARRAY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) ARRAY_Q() antlr.TerminalNode { + return s.GetToken(SnowflakeParserARRAY_Q, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BIGINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBIGINT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BINARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBINARY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBOOLEAN, 0) +} + +func (s *Supplement_non_reserved_wordsContext) BYTEINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserBYTEINT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) CHAR_VARYING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserCHAR_VARYING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATE() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATE, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DATETIME() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDATETIME, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DECIMAL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDECIMAL_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) FLOAT_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserFLOAT_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GEOGRAPHY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEOGRAPHY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GEOMETRY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserGEOMETRY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) INTEGER() antlr.TerminalNode { + return s.GetToken(SnowflakeParserINTEGER, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NCHAR_VARYING() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNCHAR_VARYING, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NUMERIC() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNUMERIC, 0) +} + +func (s *Supplement_non_reserved_wordsContext) NVARCHAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserNVARCHAR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) REAL_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserREAL_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSMALLINT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) STRING_() antlr.TerminalNode { + return s.GetToken(SnowflakeParserSTRING_, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TEXT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTEXT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) TINYINT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserTINYINT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VARBINARY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARBINARY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARCHAR, 0) +} + +func (s *Supplement_non_reserved_wordsContext) VARIANT() antlr.TerminalNode { + return s.GetToken(SnowflakeParserVARIANT, 0) +} + +func (s *Supplement_non_reserved_wordsContext) LISTAGG() antlr.TerminalNode { + return s.GetToken(SnowflakeParserLISTAGG, 0) +} + +func (s *Supplement_non_reserved_wordsContext) DUMMY() antlr.TerminalNode { + return s.GetToken(SnowflakeParserDUMMY, 0) +} + +func (s *Supplement_non_reserved_wordsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplement_non_reserved_wordsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplement_non_reserved_wordsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.EnterSupplement_non_reserved_words(s) + } +} + +func (s *Supplement_non_reserved_wordsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(SnowflakeParserListener); ok { + listenerT.ExitSupplement_non_reserved_words(s) + } +} + +func (s *Supplement_non_reserved_wordsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case SnowflakeParserVisitor: + return t.VisitSupplement_non_reserved_words(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *SnowflakeParser) Supplement_non_reserved_words() (localctx ISupplement_non_reserved_wordsContext) { + localctx = NewSupplement_non_reserved_wordsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1080, SnowflakeParserRULE_supplement_non_reserved_words) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11946) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-72067764528873986) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-81275904088604673) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-4611782775987503113) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-2458966496055953347) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-18049583418441729) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-3472275348404569605) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-75866306539601) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&9223336852482686975) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-184649784820236289) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-641)) & ^0x3f) == 0 && ((int64(1)<<(_la-641))&-1) != 0) || ((int64((_la-705)) & ^0x3f) == 0 && ((int64(1)<<(_la-705))&-4714702173379073) != 0) || ((int64((_la-769)) & ^0x3f) == 0 && ((int64(1)<<(_la-769))&-576465150349950993) != 0) || ((int64((_la-833)) & ^0x3f) == 0 && ((int64(1)<<(_la-833))&-2392537302040577) != 0) || ((int64((_la-898)) & ^0x3f) == 0 && ((int64(1)<<(_la-898))&-2358452458356865) != 0) || ((int64((_la-962)) & ^0x3f) == 0 && ((int64(1)<<(_la-962))&-504412095018729497) != 0) || ((int64((_la-1026)) & ^0x3f) == 0 && ((int64(1)<<(_la-1026))&8793920372721) != 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 +} + +func (p *SnowflakeParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 443: + var t *ExprContext = nil + if localctx != nil { + t = localctx.(*ExprContext) + } + return p.Expr_Sempred(t, predIndex) + + case 525: + var t *Search_conditionContext = nil + if localctx != nil { + t = localctx.(*Search_conditionContext) + } + return p.Search_condition_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *SnowflakeParser) Expr_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.Precpred(p.GetParserRuleContext(), 24) + + case 1: + return p.Precpred(p.GetParserRuleContext(), 23) + + case 2: + return p.Precpred(p.GetParserRuleContext(), 22) + + case 3: + return p.Precpred(p.GetParserRuleContext(), 19) + + case 4: + return p.Precpred(p.GetParserRuleContext(), 6) + + case 5: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 6: + return p.Precpred(p.GetParserRuleContext(), 31) + + case 7: + return p.Precpred(p.GetParserRuleContext(), 21) + + case 8: + return p.Precpred(p.GetParserRuleContext(), 18) + + case 9: + return p.Precpred(p.GetParserRuleContext(), 17) + + case 10: + return p.Precpred(p.GetParserRuleContext(), 16) + + case 11: + return p.Precpred(p.GetParserRuleContext(), 5) + + case 12: + return p.Precpred(p.GetParserRuleContext(), 4) + + case 13: + return p.Precpred(p.GetParserRuleContext(), 3) + + case 14: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *SnowflakeParser) Search_condition_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 15: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 16: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/snowflake/snowflakeparser_base_listener.go b/snowflake/snowflakeparser_base_listener.go new file mode 100644 index 0000000..56386eb --- /dev/null +++ b/snowflake/snowflakeparser_base_listener.go @@ -0,0 +1,3451 @@ +// Code generated from SnowflakeParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package snowflake // SnowflakeParser +import "github.com/antlr4-go/antlr/v4" + +// BaseSnowflakeParserListener is a complete listener for a parse tree produced by SnowflakeParser. +type BaseSnowflakeParserListener struct{} + +var _ SnowflakeParserListener = &BaseSnowflakeParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BaseSnowflakeParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BaseSnowflakeParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BaseSnowflakeParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BaseSnowflakeParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterSnowflake_file is called when production snowflake_file is entered. +func (s *BaseSnowflakeParserListener) EnterSnowflake_file(ctx *Snowflake_fileContext) {} + +// ExitSnowflake_file is called when production snowflake_file is exited. +func (s *BaseSnowflakeParserListener) ExitSnowflake_file(ctx *Snowflake_fileContext) {} + +// EnterBatch is called when production batch is entered. +func (s *BaseSnowflakeParserListener) EnterBatch(ctx *BatchContext) {} + +// ExitBatch is called when production batch is exited. +func (s *BaseSnowflakeParserListener) ExitBatch(ctx *BatchContext) {} + +// EnterSql_command is called when production sql_command is entered. +func (s *BaseSnowflakeParserListener) EnterSql_command(ctx *Sql_commandContext) {} + +// ExitSql_command is called when production sql_command is exited. +func (s *BaseSnowflakeParserListener) ExitSql_command(ctx *Sql_commandContext) {} + +// EnterDdl_command is called when production ddl_command is entered. +func (s *BaseSnowflakeParserListener) EnterDdl_command(ctx *Ddl_commandContext) {} + +// ExitDdl_command is called when production ddl_command is exited. +func (s *BaseSnowflakeParserListener) ExitDdl_command(ctx *Ddl_commandContext) {} + +// EnterDml_command is called when production dml_command is entered. +func (s *BaseSnowflakeParserListener) EnterDml_command(ctx *Dml_commandContext) {} + +// ExitDml_command is called when production dml_command is exited. +func (s *BaseSnowflakeParserListener) ExitDml_command(ctx *Dml_commandContext) {} + +// EnterInsert_statement is called when production insert_statement is entered. +func (s *BaseSnowflakeParserListener) EnterInsert_statement(ctx *Insert_statementContext) {} + +// ExitInsert_statement is called when production insert_statement is exited. +func (s *BaseSnowflakeParserListener) ExitInsert_statement(ctx *Insert_statementContext) {} + +// EnterInsert_multi_table_statement is called when production insert_multi_table_statement is entered. +func (s *BaseSnowflakeParserListener) EnterInsert_multi_table_statement(ctx *Insert_multi_table_statementContext) { +} + +// ExitInsert_multi_table_statement is called when production insert_multi_table_statement is exited. +func (s *BaseSnowflakeParserListener) ExitInsert_multi_table_statement(ctx *Insert_multi_table_statementContext) { +} + +// EnterInto_clause2 is called when production into_clause2 is entered. +func (s *BaseSnowflakeParserListener) EnterInto_clause2(ctx *Into_clause2Context) {} + +// ExitInto_clause2 is called when production into_clause2 is exited. +func (s *BaseSnowflakeParserListener) ExitInto_clause2(ctx *Into_clause2Context) {} + +// EnterValues_list is called when production values_list is entered. +func (s *BaseSnowflakeParserListener) EnterValues_list(ctx *Values_listContext) {} + +// ExitValues_list is called when production values_list is exited. +func (s *BaseSnowflakeParserListener) ExitValues_list(ctx *Values_listContext) {} + +// EnterValue_item is called when production value_item is entered. +func (s *BaseSnowflakeParserListener) EnterValue_item(ctx *Value_itemContext) {} + +// ExitValue_item is called when production value_item is exited. +func (s *BaseSnowflakeParserListener) ExitValue_item(ctx *Value_itemContext) {} + +// EnterMerge_statement is called when production merge_statement is entered. +func (s *BaseSnowflakeParserListener) EnterMerge_statement(ctx *Merge_statementContext) {} + +// ExitMerge_statement is called when production merge_statement is exited. +func (s *BaseSnowflakeParserListener) ExitMerge_statement(ctx *Merge_statementContext) {} + +// EnterMerge_matches is called when production merge_matches is entered. +func (s *BaseSnowflakeParserListener) EnterMerge_matches(ctx *Merge_matchesContext) {} + +// ExitMerge_matches is called when production merge_matches is exited. +func (s *BaseSnowflakeParserListener) ExitMerge_matches(ctx *Merge_matchesContext) {} + +// EnterMerge_update_delete is called when production merge_update_delete is entered. +func (s *BaseSnowflakeParserListener) EnterMerge_update_delete(ctx *Merge_update_deleteContext) {} + +// ExitMerge_update_delete is called when production merge_update_delete is exited. +func (s *BaseSnowflakeParserListener) ExitMerge_update_delete(ctx *Merge_update_deleteContext) {} + +// EnterMerge_insert is called when production merge_insert is entered. +func (s *BaseSnowflakeParserListener) EnterMerge_insert(ctx *Merge_insertContext) {} + +// ExitMerge_insert is called when production merge_insert is exited. +func (s *BaseSnowflakeParserListener) ExitMerge_insert(ctx *Merge_insertContext) {} + +// EnterUpdate_statement is called when production update_statement is entered. +func (s *BaseSnowflakeParserListener) EnterUpdate_statement(ctx *Update_statementContext) {} + +// ExitUpdate_statement is called when production update_statement is exited. +func (s *BaseSnowflakeParserListener) ExitUpdate_statement(ctx *Update_statementContext) {} + +// EnterTable_or_query is called when production table_or_query is entered. +func (s *BaseSnowflakeParserListener) EnterTable_or_query(ctx *Table_or_queryContext) {} + +// ExitTable_or_query is called when production table_or_query is exited. +func (s *BaseSnowflakeParserListener) ExitTable_or_query(ctx *Table_or_queryContext) {} + +// EnterDelete_statement is called when production delete_statement is entered. +func (s *BaseSnowflakeParserListener) EnterDelete_statement(ctx *Delete_statementContext) {} + +// ExitDelete_statement is called when production delete_statement is exited. +func (s *BaseSnowflakeParserListener) ExitDelete_statement(ctx *Delete_statementContext) {} + +// EnterValues_builder is called when production values_builder is entered. +func (s *BaseSnowflakeParserListener) EnterValues_builder(ctx *Values_builderContext) {} + +// ExitValues_builder is called when production values_builder is exited. +func (s *BaseSnowflakeParserListener) ExitValues_builder(ctx *Values_builderContext) {} + +// EnterOther_command is called when production other_command is entered. +func (s *BaseSnowflakeParserListener) EnterOther_command(ctx *Other_commandContext) {} + +// ExitOther_command is called when production other_command is exited. +func (s *BaseSnowflakeParserListener) ExitOther_command(ctx *Other_commandContext) {} + +// EnterCopy_into_table is called when production copy_into_table is entered. +func (s *BaseSnowflakeParserListener) EnterCopy_into_table(ctx *Copy_into_tableContext) {} + +// ExitCopy_into_table is called when production copy_into_table is exited. +func (s *BaseSnowflakeParserListener) ExitCopy_into_table(ctx *Copy_into_tableContext) {} + +// EnterExternal_location is called when production external_location is entered. +func (s *BaseSnowflakeParserListener) EnterExternal_location(ctx *External_locationContext) {} + +// ExitExternal_location is called when production external_location is exited. +func (s *BaseSnowflakeParserListener) ExitExternal_location(ctx *External_locationContext) {} + +// EnterFiles is called when production files is entered. +func (s *BaseSnowflakeParserListener) EnterFiles(ctx *FilesContext) {} + +// ExitFiles is called when production files is exited. +func (s *BaseSnowflakeParserListener) ExitFiles(ctx *FilesContext) {} + +// EnterFile_format is called when production file_format is entered. +func (s *BaseSnowflakeParserListener) EnterFile_format(ctx *File_formatContext) {} + +// ExitFile_format is called when production file_format is exited. +func (s *BaseSnowflakeParserListener) ExitFile_format(ctx *File_formatContext) {} + +// EnterFormat_name is called when production format_name is entered. +func (s *BaseSnowflakeParserListener) EnterFormat_name(ctx *Format_nameContext) {} + +// ExitFormat_name is called when production format_name is exited. +func (s *BaseSnowflakeParserListener) ExitFormat_name(ctx *Format_nameContext) {} + +// EnterFormat_type is called when production format_type is entered. +func (s *BaseSnowflakeParserListener) EnterFormat_type(ctx *Format_typeContext) {} + +// ExitFormat_type is called when production format_type is exited. +func (s *BaseSnowflakeParserListener) ExitFormat_type(ctx *Format_typeContext) {} + +// EnterStage_file_format is called when production stage_file_format is entered. +func (s *BaseSnowflakeParserListener) EnterStage_file_format(ctx *Stage_file_formatContext) {} + +// ExitStage_file_format is called when production stage_file_format is exited. +func (s *BaseSnowflakeParserListener) ExitStage_file_format(ctx *Stage_file_formatContext) {} + +// EnterCopy_into_location is called when production copy_into_location is entered. +func (s *BaseSnowflakeParserListener) EnterCopy_into_location(ctx *Copy_into_locationContext) {} + +// ExitCopy_into_location is called when production copy_into_location is exited. +func (s *BaseSnowflakeParserListener) ExitCopy_into_location(ctx *Copy_into_locationContext) {} + +// EnterComment is called when production comment is entered. +func (s *BaseSnowflakeParserListener) EnterComment(ctx *CommentContext) {} + +// ExitComment is called when production comment is exited. +func (s *BaseSnowflakeParserListener) ExitComment(ctx *CommentContext) {} + +// EnterCommit is called when production commit is entered. +func (s *BaseSnowflakeParserListener) EnterCommit(ctx *CommitContext) {} + +// ExitCommit is called when production commit is exited. +func (s *BaseSnowflakeParserListener) ExitCommit(ctx *CommitContext) {} + +// EnterExecute_immediate is called when production execute_immediate is entered. +func (s *BaseSnowflakeParserListener) EnterExecute_immediate(ctx *Execute_immediateContext) {} + +// ExitExecute_immediate is called when production execute_immediate is exited. +func (s *BaseSnowflakeParserListener) ExitExecute_immediate(ctx *Execute_immediateContext) {} + +// EnterExecute_task is called when production execute_task is entered. +func (s *BaseSnowflakeParserListener) EnterExecute_task(ctx *Execute_taskContext) {} + +// ExitExecute_task is called when production execute_task is exited. +func (s *BaseSnowflakeParserListener) ExitExecute_task(ctx *Execute_taskContext) {} + +// EnterExplain is called when production explain is entered. +func (s *BaseSnowflakeParserListener) EnterExplain(ctx *ExplainContext) {} + +// ExitExplain is called when production explain is exited. +func (s *BaseSnowflakeParserListener) ExitExplain(ctx *ExplainContext) {} + +// EnterParallel is called when production parallel is entered. +func (s *BaseSnowflakeParserListener) EnterParallel(ctx *ParallelContext) {} + +// ExitParallel is called when production parallel is exited. +func (s *BaseSnowflakeParserListener) ExitParallel(ctx *ParallelContext) {} + +// EnterGet_dml is called when production get_dml is entered. +func (s *BaseSnowflakeParserListener) EnterGet_dml(ctx *Get_dmlContext) {} + +// ExitGet_dml is called when production get_dml is exited. +func (s *BaseSnowflakeParserListener) ExitGet_dml(ctx *Get_dmlContext) {} + +// EnterGrant_ownership is called when production grant_ownership is entered. +func (s *BaseSnowflakeParserListener) EnterGrant_ownership(ctx *Grant_ownershipContext) {} + +// ExitGrant_ownership is called when production grant_ownership is exited. +func (s *BaseSnowflakeParserListener) ExitGrant_ownership(ctx *Grant_ownershipContext) {} + +// EnterGrant_to_role is called when production grant_to_role is entered. +func (s *BaseSnowflakeParserListener) EnterGrant_to_role(ctx *Grant_to_roleContext) {} + +// ExitGrant_to_role is called when production grant_to_role is exited. +func (s *BaseSnowflakeParserListener) ExitGrant_to_role(ctx *Grant_to_roleContext) {} + +// EnterGlobal_privileges is called when production global_privileges is entered. +func (s *BaseSnowflakeParserListener) EnterGlobal_privileges(ctx *Global_privilegesContext) {} + +// ExitGlobal_privileges is called when production global_privileges is exited. +func (s *BaseSnowflakeParserListener) ExitGlobal_privileges(ctx *Global_privilegesContext) {} + +// EnterGlobal_privilege is called when production global_privilege is entered. +func (s *BaseSnowflakeParserListener) EnterGlobal_privilege(ctx *Global_privilegeContext) {} + +// ExitGlobal_privilege is called when production global_privilege is exited. +func (s *BaseSnowflakeParserListener) ExitGlobal_privilege(ctx *Global_privilegeContext) {} + +// EnterAccount_object_privileges is called when production account_object_privileges is entered. +func (s *BaseSnowflakeParserListener) EnterAccount_object_privileges(ctx *Account_object_privilegesContext) { +} + +// ExitAccount_object_privileges is called when production account_object_privileges is exited. +func (s *BaseSnowflakeParserListener) ExitAccount_object_privileges(ctx *Account_object_privilegesContext) { +} + +// EnterAccount_object_privilege is called when production account_object_privilege is entered. +func (s *BaseSnowflakeParserListener) EnterAccount_object_privilege(ctx *Account_object_privilegeContext) { +} + +// ExitAccount_object_privilege is called when production account_object_privilege is exited. +func (s *BaseSnowflakeParserListener) ExitAccount_object_privilege(ctx *Account_object_privilegeContext) { +} + +// EnterSchema_privileges is called when production schema_privileges is entered. +func (s *BaseSnowflakeParserListener) EnterSchema_privileges(ctx *Schema_privilegesContext) {} + +// ExitSchema_privileges is called when production schema_privileges is exited. +func (s *BaseSnowflakeParserListener) ExitSchema_privileges(ctx *Schema_privilegesContext) {} + +// EnterSchema_privilege is called when production schema_privilege is entered. +func (s *BaseSnowflakeParserListener) EnterSchema_privilege(ctx *Schema_privilegeContext) {} + +// ExitSchema_privilege is called when production schema_privilege is exited. +func (s *BaseSnowflakeParserListener) ExitSchema_privilege(ctx *Schema_privilegeContext) {} + +// EnterSchema_object_privileges is called when production schema_object_privileges is entered. +func (s *BaseSnowflakeParserListener) EnterSchema_object_privileges(ctx *Schema_object_privilegesContext) { +} + +// ExitSchema_object_privileges is called when production schema_object_privileges is exited. +func (s *BaseSnowflakeParserListener) ExitSchema_object_privileges(ctx *Schema_object_privilegesContext) { +} + +// EnterSchema_object_privilege is called when production schema_object_privilege is entered. +func (s *BaseSnowflakeParserListener) EnterSchema_object_privilege(ctx *Schema_object_privilegeContext) { +} + +// ExitSchema_object_privilege is called when production schema_object_privilege is exited. +func (s *BaseSnowflakeParserListener) ExitSchema_object_privilege(ctx *Schema_object_privilegeContext) { +} + +// EnterGrant_to_share is called when production grant_to_share is entered. +func (s *BaseSnowflakeParserListener) EnterGrant_to_share(ctx *Grant_to_shareContext) {} + +// ExitGrant_to_share is called when production grant_to_share is exited. +func (s *BaseSnowflakeParserListener) ExitGrant_to_share(ctx *Grant_to_shareContext) {} + +// EnterObject_privilege is called when production object_privilege is entered. +func (s *BaseSnowflakeParserListener) EnterObject_privilege(ctx *Object_privilegeContext) {} + +// ExitObject_privilege is called when production object_privilege is exited. +func (s *BaseSnowflakeParserListener) ExitObject_privilege(ctx *Object_privilegeContext) {} + +// EnterGrant_role is called when production grant_role is entered. +func (s *BaseSnowflakeParserListener) EnterGrant_role(ctx *Grant_roleContext) {} + +// ExitGrant_role is called when production grant_role is exited. +func (s *BaseSnowflakeParserListener) ExitGrant_role(ctx *Grant_roleContext) {} + +// EnterRole_name is called when production role_name is entered. +func (s *BaseSnowflakeParserListener) EnterRole_name(ctx *Role_nameContext) {} + +// ExitRole_name is called when production role_name is exited. +func (s *BaseSnowflakeParserListener) ExitRole_name(ctx *Role_nameContext) {} + +// EnterSystem_defined_role is called when production system_defined_role is entered. +func (s *BaseSnowflakeParserListener) EnterSystem_defined_role(ctx *System_defined_roleContext) {} + +// ExitSystem_defined_role is called when production system_defined_role is exited. +func (s *BaseSnowflakeParserListener) ExitSystem_defined_role(ctx *System_defined_roleContext) {} + +// EnterList is called when production list is entered. +func (s *BaseSnowflakeParserListener) EnterList(ctx *ListContext) {} + +// ExitList is called when production list is exited. +func (s *BaseSnowflakeParserListener) ExitList(ctx *ListContext) {} + +// EnterInternal_stage is called when production internal_stage is entered. +func (s *BaseSnowflakeParserListener) EnterInternal_stage(ctx *Internal_stageContext) {} + +// ExitInternal_stage is called when production internal_stage is exited. +func (s *BaseSnowflakeParserListener) ExitInternal_stage(ctx *Internal_stageContext) {} + +// EnterExternal_stage is called when production external_stage is entered. +func (s *BaseSnowflakeParserListener) EnterExternal_stage(ctx *External_stageContext) {} + +// ExitExternal_stage is called when production external_stage is exited. +func (s *BaseSnowflakeParserListener) ExitExternal_stage(ctx *External_stageContext) {} + +// EnterPut is called when production put is entered. +func (s *BaseSnowflakeParserListener) EnterPut(ctx *PutContext) {} + +// ExitPut is called when production put is exited. +func (s *BaseSnowflakeParserListener) ExitPut(ctx *PutContext) {} + +// EnterRemove is called when production remove is entered. +func (s *BaseSnowflakeParserListener) EnterRemove(ctx *RemoveContext) {} + +// ExitRemove is called when production remove is exited. +func (s *BaseSnowflakeParserListener) ExitRemove(ctx *RemoveContext) {} + +// EnterRevoke_from_role is called when production revoke_from_role is entered. +func (s *BaseSnowflakeParserListener) EnterRevoke_from_role(ctx *Revoke_from_roleContext) {} + +// ExitRevoke_from_role is called when production revoke_from_role is exited. +func (s *BaseSnowflakeParserListener) ExitRevoke_from_role(ctx *Revoke_from_roleContext) {} + +// EnterRevoke_from_share is called when production revoke_from_share is entered. +func (s *BaseSnowflakeParserListener) EnterRevoke_from_share(ctx *Revoke_from_shareContext) {} + +// ExitRevoke_from_share is called when production revoke_from_share is exited. +func (s *BaseSnowflakeParserListener) ExitRevoke_from_share(ctx *Revoke_from_shareContext) {} + +// EnterRevoke_role is called when production revoke_role is entered. +func (s *BaseSnowflakeParserListener) EnterRevoke_role(ctx *Revoke_roleContext) {} + +// ExitRevoke_role is called when production revoke_role is exited. +func (s *BaseSnowflakeParserListener) ExitRevoke_role(ctx *Revoke_roleContext) {} + +// EnterRollback is called when production rollback is entered. +func (s *BaseSnowflakeParserListener) EnterRollback(ctx *RollbackContext) {} + +// ExitRollback is called when production rollback is exited. +func (s *BaseSnowflakeParserListener) ExitRollback(ctx *RollbackContext) {} + +// EnterSet is called when production set is entered. +func (s *BaseSnowflakeParserListener) EnterSet(ctx *SetContext) {} + +// ExitSet is called when production set is exited. +func (s *BaseSnowflakeParserListener) ExitSet(ctx *SetContext) {} + +// EnterTruncate_materialized_view is called when production truncate_materialized_view is entered. +func (s *BaseSnowflakeParserListener) EnterTruncate_materialized_view(ctx *Truncate_materialized_viewContext) { +} + +// ExitTruncate_materialized_view is called when production truncate_materialized_view is exited. +func (s *BaseSnowflakeParserListener) ExitTruncate_materialized_view(ctx *Truncate_materialized_viewContext) { +} + +// EnterTruncate_table is called when production truncate_table is entered. +func (s *BaseSnowflakeParserListener) EnterTruncate_table(ctx *Truncate_tableContext) {} + +// ExitTruncate_table is called when production truncate_table is exited. +func (s *BaseSnowflakeParserListener) ExitTruncate_table(ctx *Truncate_tableContext) {} + +// EnterUnset is called when production unset is entered. +func (s *BaseSnowflakeParserListener) EnterUnset(ctx *UnsetContext) {} + +// ExitUnset is called when production unset is exited. +func (s *BaseSnowflakeParserListener) ExitUnset(ctx *UnsetContext) {} + +// EnterAlter_command is called when production alter_command is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_command(ctx *Alter_commandContext) {} + +// ExitAlter_command is called when production alter_command is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_command(ctx *Alter_commandContext) {} + +// EnterAccount_params is called when production account_params is entered. +func (s *BaseSnowflakeParserListener) EnterAccount_params(ctx *Account_paramsContext) {} + +// ExitAccount_params is called when production account_params is exited. +func (s *BaseSnowflakeParserListener) ExitAccount_params(ctx *Account_paramsContext) {} + +// EnterObject_params is called when production object_params is entered. +func (s *BaseSnowflakeParserListener) EnterObject_params(ctx *Object_paramsContext) {} + +// ExitObject_params is called when production object_params is exited. +func (s *BaseSnowflakeParserListener) ExitObject_params(ctx *Object_paramsContext) {} + +// EnterDefault_ddl_collation is called when production default_ddl_collation is entered. +func (s *BaseSnowflakeParserListener) EnterDefault_ddl_collation(ctx *Default_ddl_collationContext) {} + +// ExitDefault_ddl_collation is called when production default_ddl_collation is exited. +func (s *BaseSnowflakeParserListener) ExitDefault_ddl_collation(ctx *Default_ddl_collationContext) {} + +// EnterObject_properties is called when production object_properties is entered. +func (s *BaseSnowflakeParserListener) EnterObject_properties(ctx *Object_propertiesContext) {} + +// ExitObject_properties is called when production object_properties is exited. +func (s *BaseSnowflakeParserListener) ExitObject_properties(ctx *Object_propertiesContext) {} + +// EnterSession_params is called when production session_params is entered. +func (s *BaseSnowflakeParserListener) EnterSession_params(ctx *Session_paramsContext) {} + +// ExitSession_params is called when production session_params is exited. +func (s *BaseSnowflakeParserListener) ExitSession_params(ctx *Session_paramsContext) {} + +// EnterAlter_account is called when production alter_account is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_account(ctx *Alter_accountContext) {} + +// ExitAlter_account is called when production alter_account is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_account(ctx *Alter_accountContext) {} + +// EnterEnabled_true_false is called when production enabled_true_false is entered. +func (s *BaseSnowflakeParserListener) EnterEnabled_true_false(ctx *Enabled_true_falseContext) {} + +// ExitEnabled_true_false is called when production enabled_true_false is exited. +func (s *BaseSnowflakeParserListener) ExitEnabled_true_false(ctx *Enabled_true_falseContext) {} + +// EnterAlter_alert is called when production alter_alert is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_alert(ctx *Alter_alertContext) {} + +// ExitAlter_alert is called when production alter_alert is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_alert(ctx *Alter_alertContext) {} + +// EnterResume_suspend is called when production resume_suspend is entered. +func (s *BaseSnowflakeParserListener) EnterResume_suspend(ctx *Resume_suspendContext) {} + +// ExitResume_suspend is called when production resume_suspend is exited. +func (s *BaseSnowflakeParserListener) ExitResume_suspend(ctx *Resume_suspendContext) {} + +// EnterAlert_set_clause is called when production alert_set_clause is entered. +func (s *BaseSnowflakeParserListener) EnterAlert_set_clause(ctx *Alert_set_clauseContext) {} + +// ExitAlert_set_clause is called when production alert_set_clause is exited. +func (s *BaseSnowflakeParserListener) ExitAlert_set_clause(ctx *Alert_set_clauseContext) {} + +// EnterAlert_unset_clause is called when production alert_unset_clause is entered. +func (s *BaseSnowflakeParserListener) EnterAlert_unset_clause(ctx *Alert_unset_clauseContext) {} + +// ExitAlert_unset_clause is called when production alert_unset_clause is exited. +func (s *BaseSnowflakeParserListener) ExitAlert_unset_clause(ctx *Alert_unset_clauseContext) {} + +// EnterAlter_api_integration is called when production alter_api_integration is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_api_integration(ctx *Alter_api_integrationContext) {} + +// ExitAlter_api_integration is called when production alter_api_integration is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_api_integration(ctx *Alter_api_integrationContext) {} + +// EnterApi_integration_property is called when production api_integration_property is entered. +func (s *BaseSnowflakeParserListener) EnterApi_integration_property(ctx *Api_integration_propertyContext) { +} + +// ExitApi_integration_property is called when production api_integration_property is exited. +func (s *BaseSnowflakeParserListener) ExitApi_integration_property(ctx *Api_integration_propertyContext) { +} + +// EnterAlter_connection is called when production alter_connection is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_connection(ctx *Alter_connectionContext) {} + +// ExitAlter_connection is called when production alter_connection is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_connection(ctx *Alter_connectionContext) {} + +// EnterAlter_database is called when production alter_database is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_database(ctx *Alter_databaseContext) {} + +// ExitAlter_database is called when production alter_database is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_database(ctx *Alter_databaseContext) {} + +// EnterDatabase_property is called when production database_property is entered. +func (s *BaseSnowflakeParserListener) EnterDatabase_property(ctx *Database_propertyContext) {} + +// ExitDatabase_property is called when production database_property is exited. +func (s *BaseSnowflakeParserListener) ExitDatabase_property(ctx *Database_propertyContext) {} + +// EnterAccount_id_list is called when production account_id_list is entered. +func (s *BaseSnowflakeParserListener) EnterAccount_id_list(ctx *Account_id_listContext) {} + +// ExitAccount_id_list is called when production account_id_list is exited. +func (s *BaseSnowflakeParserListener) ExitAccount_id_list(ctx *Account_id_listContext) {} + +// EnterAlter_dynamic_table is called when production alter_dynamic_table is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_dynamic_table(ctx *Alter_dynamic_tableContext) {} + +// ExitAlter_dynamic_table is called when production alter_dynamic_table is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_dynamic_table(ctx *Alter_dynamic_tableContext) {} + +// EnterAlter_external_table is called when production alter_external_table is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_external_table(ctx *Alter_external_tableContext) {} + +// ExitAlter_external_table is called when production alter_external_table is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_external_table(ctx *Alter_external_tableContext) {} + +// EnterIgnore_edition_check is called when production ignore_edition_check is entered. +func (s *BaseSnowflakeParserListener) EnterIgnore_edition_check(ctx *Ignore_edition_checkContext) {} + +// ExitIgnore_edition_check is called when production ignore_edition_check is exited. +func (s *BaseSnowflakeParserListener) ExitIgnore_edition_check(ctx *Ignore_edition_checkContext) {} + +// EnterReplication_schedule is called when production replication_schedule is entered. +func (s *BaseSnowflakeParserListener) EnterReplication_schedule(ctx *Replication_scheduleContext) {} + +// ExitReplication_schedule is called when production replication_schedule is exited. +func (s *BaseSnowflakeParserListener) ExitReplication_schedule(ctx *Replication_scheduleContext) {} + +// EnterDb_name_list is called when production db_name_list is entered. +func (s *BaseSnowflakeParserListener) EnterDb_name_list(ctx *Db_name_listContext) {} + +// ExitDb_name_list is called when production db_name_list is exited. +func (s *BaseSnowflakeParserListener) ExitDb_name_list(ctx *Db_name_listContext) {} + +// EnterShare_name_list is called when production share_name_list is entered. +func (s *BaseSnowflakeParserListener) EnterShare_name_list(ctx *Share_name_listContext) {} + +// ExitShare_name_list is called when production share_name_list is exited. +func (s *BaseSnowflakeParserListener) ExitShare_name_list(ctx *Share_name_listContext) {} + +// EnterFull_acct_list is called when production full_acct_list is entered. +func (s *BaseSnowflakeParserListener) EnterFull_acct_list(ctx *Full_acct_listContext) {} + +// ExitFull_acct_list is called when production full_acct_list is exited. +func (s *BaseSnowflakeParserListener) ExitFull_acct_list(ctx *Full_acct_listContext) {} + +// EnterAlter_failover_group is called when production alter_failover_group is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_failover_group(ctx *Alter_failover_groupContext) {} + +// ExitAlter_failover_group is called when production alter_failover_group is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_failover_group(ctx *Alter_failover_groupContext) {} + +// EnterAlter_file_format is called when production alter_file_format is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_file_format(ctx *Alter_file_formatContext) {} + +// ExitAlter_file_format is called when production alter_file_format is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_file_format(ctx *Alter_file_formatContext) {} + +// EnterAlter_function is called when production alter_function is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_function(ctx *Alter_functionContext) {} + +// ExitAlter_function is called when production alter_function is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_function(ctx *Alter_functionContext) {} + +// EnterAlter_function_signature is called when production alter_function_signature is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_function_signature(ctx *Alter_function_signatureContext) { +} + +// ExitAlter_function_signature is called when production alter_function_signature is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_function_signature(ctx *Alter_function_signatureContext) { +} + +// EnterData_type_list is called when production data_type_list is entered. +func (s *BaseSnowflakeParserListener) EnterData_type_list(ctx *Data_type_listContext) {} + +// ExitData_type_list is called when production data_type_list is exited. +func (s *BaseSnowflakeParserListener) ExitData_type_list(ctx *Data_type_listContext) {} + +// EnterAlter_masking_policy is called when production alter_masking_policy is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_masking_policy(ctx *Alter_masking_policyContext) {} + +// ExitAlter_masking_policy is called when production alter_masking_policy is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_masking_policy(ctx *Alter_masking_policyContext) {} + +// EnterAlter_materialized_view is called when production alter_materialized_view is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_materialized_view(ctx *Alter_materialized_viewContext) { +} + +// ExitAlter_materialized_view is called when production alter_materialized_view is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_materialized_view(ctx *Alter_materialized_viewContext) { +} + +// EnterAlter_network_policy is called when production alter_network_policy is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_network_policy(ctx *Alter_network_policyContext) {} + +// ExitAlter_network_policy is called when production alter_network_policy is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_network_policy(ctx *Alter_network_policyContext) {} + +// EnterAlter_notification_integration is called when production alter_notification_integration is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_notification_integration(ctx *Alter_notification_integrationContext) { +} + +// ExitAlter_notification_integration is called when production alter_notification_integration is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_notification_integration(ctx *Alter_notification_integrationContext) { +} + +// EnterAlter_pipe is called when production alter_pipe is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_pipe(ctx *Alter_pipeContext) {} + +// ExitAlter_pipe is called when production alter_pipe is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_pipe(ctx *Alter_pipeContext) {} + +// EnterAlter_procedure is called when production alter_procedure is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_procedure(ctx *Alter_procedureContext) {} + +// ExitAlter_procedure is called when production alter_procedure is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_procedure(ctx *Alter_procedureContext) {} + +// EnterAlter_replication_group is called when production alter_replication_group is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_replication_group(ctx *Alter_replication_groupContext) { +} + +// ExitAlter_replication_group is called when production alter_replication_group is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_replication_group(ctx *Alter_replication_groupContext) { +} + +// EnterCredit_quota is called when production credit_quota is entered. +func (s *BaseSnowflakeParserListener) EnterCredit_quota(ctx *Credit_quotaContext) {} + +// ExitCredit_quota is called when production credit_quota is exited. +func (s *BaseSnowflakeParserListener) ExitCredit_quota(ctx *Credit_quotaContext) {} + +// EnterFrequency is called when production frequency is entered. +func (s *BaseSnowflakeParserListener) EnterFrequency(ctx *FrequencyContext) {} + +// ExitFrequency is called when production frequency is exited. +func (s *BaseSnowflakeParserListener) ExitFrequency(ctx *FrequencyContext) {} + +// EnterNotify_users is called when production notify_users is entered. +func (s *BaseSnowflakeParserListener) EnterNotify_users(ctx *Notify_usersContext) {} + +// ExitNotify_users is called when production notify_users is exited. +func (s *BaseSnowflakeParserListener) ExitNotify_users(ctx *Notify_usersContext) {} + +// EnterTriggerDefinition is called when production triggerDefinition is entered. +func (s *BaseSnowflakeParserListener) EnterTriggerDefinition(ctx *TriggerDefinitionContext) {} + +// ExitTriggerDefinition is called when production triggerDefinition is exited. +func (s *BaseSnowflakeParserListener) ExitTriggerDefinition(ctx *TriggerDefinitionContext) {} + +// EnterAlter_resource_monitor is called when production alter_resource_monitor is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_resource_monitor(ctx *Alter_resource_monitorContext) { +} + +// ExitAlter_resource_monitor is called when production alter_resource_monitor is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_resource_monitor(ctx *Alter_resource_monitorContext) { +} + +// EnterAlter_role is called when production alter_role is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_role(ctx *Alter_roleContext) {} + +// ExitAlter_role is called when production alter_role is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_role(ctx *Alter_roleContext) {} + +// EnterAlter_row_access_policy is called when production alter_row_access_policy is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_row_access_policy(ctx *Alter_row_access_policyContext) { +} + +// ExitAlter_row_access_policy is called when production alter_row_access_policy is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_row_access_policy(ctx *Alter_row_access_policyContext) { +} + +// EnterAlter_schema is called when production alter_schema is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_schema(ctx *Alter_schemaContext) {} + +// ExitAlter_schema is called when production alter_schema is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_schema(ctx *Alter_schemaContext) {} + +// EnterSchema_property is called when production schema_property is entered. +func (s *BaseSnowflakeParserListener) EnterSchema_property(ctx *Schema_propertyContext) {} + +// ExitSchema_property is called when production schema_property is exited. +func (s *BaseSnowflakeParserListener) ExitSchema_property(ctx *Schema_propertyContext) {} + +// EnterAlter_security_integration is called when production alter_security_integration is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_security_integration(ctx *Alter_security_integrationContext) { +} + +// ExitAlter_security_integration is called when production alter_security_integration is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_security_integration(ctx *Alter_security_integrationContext) { +} + +// EnterAlter_security_integration_external_oauth is called when production alter_security_integration_external_oauth is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_security_integration_external_oauth(ctx *Alter_security_integration_external_oauthContext) { +} + +// ExitAlter_security_integration_external_oauth is called when production alter_security_integration_external_oauth is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_security_integration_external_oauth(ctx *Alter_security_integration_external_oauthContext) { +} + +// EnterSecurity_integration_external_oauth_property is called when production security_integration_external_oauth_property is entered. +func (s *BaseSnowflakeParserListener) EnterSecurity_integration_external_oauth_property(ctx *Security_integration_external_oauth_propertyContext) { +} + +// ExitSecurity_integration_external_oauth_property is called when production security_integration_external_oauth_property is exited. +func (s *BaseSnowflakeParserListener) ExitSecurity_integration_external_oauth_property(ctx *Security_integration_external_oauth_propertyContext) { +} + +// EnterAlter_security_integration_snowflake_oauth is called when production alter_security_integration_snowflake_oauth is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_security_integration_snowflake_oauth(ctx *Alter_security_integration_snowflake_oauthContext) { +} + +// ExitAlter_security_integration_snowflake_oauth is called when production alter_security_integration_snowflake_oauth is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_security_integration_snowflake_oauth(ctx *Alter_security_integration_snowflake_oauthContext) { +} + +// EnterSecurity_integration_snowflake_oauth_property is called when production security_integration_snowflake_oauth_property is entered. +func (s *BaseSnowflakeParserListener) EnterSecurity_integration_snowflake_oauth_property(ctx *Security_integration_snowflake_oauth_propertyContext) { +} + +// ExitSecurity_integration_snowflake_oauth_property is called when production security_integration_snowflake_oauth_property is exited. +func (s *BaseSnowflakeParserListener) ExitSecurity_integration_snowflake_oauth_property(ctx *Security_integration_snowflake_oauth_propertyContext) { +} + +// EnterAlter_security_integration_saml2 is called when production alter_security_integration_saml2 is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_security_integration_saml2(ctx *Alter_security_integration_saml2Context) { +} + +// ExitAlter_security_integration_saml2 is called when production alter_security_integration_saml2 is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_security_integration_saml2(ctx *Alter_security_integration_saml2Context) { +} + +// EnterAlter_security_integration_scim is called when production alter_security_integration_scim is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_security_integration_scim(ctx *Alter_security_integration_scimContext) { +} + +// ExitAlter_security_integration_scim is called when production alter_security_integration_scim is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_security_integration_scim(ctx *Alter_security_integration_scimContext) { +} + +// EnterSecurity_integration_scim_property is called when production security_integration_scim_property is entered. +func (s *BaseSnowflakeParserListener) EnterSecurity_integration_scim_property(ctx *Security_integration_scim_propertyContext) { +} + +// ExitSecurity_integration_scim_property is called when production security_integration_scim_property is exited. +func (s *BaseSnowflakeParserListener) ExitSecurity_integration_scim_property(ctx *Security_integration_scim_propertyContext) { +} + +// EnterAlter_sequence is called when production alter_sequence is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_sequence(ctx *Alter_sequenceContext) {} + +// ExitAlter_sequence is called when production alter_sequence is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_sequence(ctx *Alter_sequenceContext) {} + +// EnterAlter_session is called when production alter_session is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_session(ctx *Alter_sessionContext) {} + +// ExitAlter_session is called when production alter_session is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_session(ctx *Alter_sessionContext) {} + +// EnterAlter_session_policy is called when production alter_session_policy is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_session_policy(ctx *Alter_session_policyContext) {} + +// ExitAlter_session_policy is called when production alter_session_policy is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_session_policy(ctx *Alter_session_policyContext) {} + +// EnterAlter_share is called when production alter_share is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_share(ctx *Alter_shareContext) {} + +// ExitAlter_share is called when production alter_share is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_share(ctx *Alter_shareContext) {} + +// EnterAlter_stage is called when production alter_stage is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_stage(ctx *Alter_stageContext) {} + +// ExitAlter_stage is called when production alter_stage is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_stage(ctx *Alter_stageContext) {} + +// EnterAlter_storage_integration is called when production alter_storage_integration is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_storage_integration(ctx *Alter_storage_integrationContext) { +} + +// ExitAlter_storage_integration is called when production alter_storage_integration is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_storage_integration(ctx *Alter_storage_integrationContext) { +} + +// EnterAlter_stream is called when production alter_stream is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_stream(ctx *Alter_streamContext) {} + +// ExitAlter_stream is called when production alter_stream is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_stream(ctx *Alter_streamContext) {} + +// EnterAlter_table is called when production alter_table is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_table(ctx *Alter_tableContext) {} + +// ExitAlter_table is called when production alter_table is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_table(ctx *Alter_tableContext) {} + +// EnterClustering_action is called when production clustering_action is entered. +func (s *BaseSnowflakeParserListener) EnterClustering_action(ctx *Clustering_actionContext) {} + +// ExitClustering_action is called when production clustering_action is exited. +func (s *BaseSnowflakeParserListener) ExitClustering_action(ctx *Clustering_actionContext) {} + +// EnterTable_column_action is called when production table_column_action is entered. +func (s *BaseSnowflakeParserListener) EnterTable_column_action(ctx *Table_column_actionContext) {} + +// ExitTable_column_action is called when production table_column_action is exited. +func (s *BaseSnowflakeParserListener) ExitTable_column_action(ctx *Table_column_actionContext) {} + +// EnterInline_constraint is called when production inline_constraint is entered. +func (s *BaseSnowflakeParserListener) EnterInline_constraint(ctx *Inline_constraintContext) {} + +// ExitInline_constraint is called when production inline_constraint is exited. +func (s *BaseSnowflakeParserListener) ExitInline_constraint(ctx *Inline_constraintContext) {} + +// EnterConstraint_properties is called when production constraint_properties is entered. +func (s *BaseSnowflakeParserListener) EnterConstraint_properties(ctx *Constraint_propertiesContext) {} + +// ExitConstraint_properties is called when production constraint_properties is exited. +func (s *BaseSnowflakeParserListener) ExitConstraint_properties(ctx *Constraint_propertiesContext) {} + +// EnterExt_table_column_action is called when production ext_table_column_action is entered. +func (s *BaseSnowflakeParserListener) EnterExt_table_column_action(ctx *Ext_table_column_actionContext) { +} + +// ExitExt_table_column_action is called when production ext_table_column_action is exited. +func (s *BaseSnowflakeParserListener) ExitExt_table_column_action(ctx *Ext_table_column_actionContext) { +} + +// EnterConstraint_action is called when production constraint_action is entered. +func (s *BaseSnowflakeParserListener) EnterConstraint_action(ctx *Constraint_actionContext) {} + +// ExitConstraint_action is called when production constraint_action is exited. +func (s *BaseSnowflakeParserListener) ExitConstraint_action(ctx *Constraint_actionContext) {} + +// EnterSearch_optimization_action is called when production search_optimization_action is entered. +func (s *BaseSnowflakeParserListener) EnterSearch_optimization_action(ctx *Search_optimization_actionContext) { +} + +// ExitSearch_optimization_action is called when production search_optimization_action is exited. +func (s *BaseSnowflakeParserListener) ExitSearch_optimization_action(ctx *Search_optimization_actionContext) { +} + +// EnterSearch_method_with_target is called when production search_method_with_target is entered. +func (s *BaseSnowflakeParserListener) EnterSearch_method_with_target(ctx *Search_method_with_targetContext) { +} + +// ExitSearch_method_with_target is called when production search_method_with_target is exited. +func (s *BaseSnowflakeParserListener) ExitSearch_method_with_target(ctx *Search_method_with_targetContext) { +} + +// EnterAlter_table_alter_column is called when production alter_table_alter_column is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_table_alter_column(ctx *Alter_table_alter_columnContext) { +} + +// ExitAlter_table_alter_column is called when production alter_table_alter_column is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_table_alter_column(ctx *Alter_table_alter_columnContext) { +} + +// EnterAlter_column_decl_list is called when production alter_column_decl_list is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_column_decl_list(ctx *Alter_column_decl_listContext) { +} + +// ExitAlter_column_decl_list is called when production alter_column_decl_list is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_column_decl_list(ctx *Alter_column_decl_listContext) { +} + +// EnterAlter_column_decl is called when production alter_column_decl is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_column_decl(ctx *Alter_column_declContext) {} + +// ExitAlter_column_decl is called when production alter_column_decl is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_column_decl(ctx *Alter_column_declContext) {} + +// EnterAlter_column_opts is called when production alter_column_opts is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_column_opts(ctx *Alter_column_optsContext) {} + +// ExitAlter_column_opts is called when production alter_column_opts is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_column_opts(ctx *Alter_column_optsContext) {} + +// EnterColumn_set_tags is called when production column_set_tags is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_set_tags(ctx *Column_set_tagsContext) {} + +// ExitColumn_set_tags is called when production column_set_tags is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_set_tags(ctx *Column_set_tagsContext) {} + +// EnterColumn_unset_tags is called when production column_unset_tags is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_unset_tags(ctx *Column_unset_tagsContext) {} + +// ExitColumn_unset_tags is called when production column_unset_tags is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_unset_tags(ctx *Column_unset_tagsContext) {} + +// EnterAlter_tag is called when production alter_tag is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_tag(ctx *Alter_tagContext) {} + +// ExitAlter_tag is called when production alter_tag is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_tag(ctx *Alter_tagContext) {} + +// EnterAlter_task is called when production alter_task is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_task(ctx *Alter_taskContext) {} + +// ExitAlter_task is called when production alter_task is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_task(ctx *Alter_taskContext) {} + +// EnterAlter_user is called when production alter_user is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_user(ctx *Alter_userContext) {} + +// ExitAlter_user is called when production alter_user is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_user(ctx *Alter_userContext) {} + +// EnterAlter_view is called when production alter_view is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_view(ctx *Alter_viewContext) {} + +// ExitAlter_view is called when production alter_view is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_view(ctx *Alter_viewContext) {} + +// EnterAlter_modify is called when production alter_modify is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_modify(ctx *Alter_modifyContext) {} + +// ExitAlter_modify is called when production alter_modify is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_modify(ctx *Alter_modifyContext) {} + +// EnterAlter_warehouse is called when production alter_warehouse is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_warehouse(ctx *Alter_warehouseContext) {} + +// ExitAlter_warehouse is called when production alter_warehouse is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_warehouse(ctx *Alter_warehouseContext) {} + +// EnterAlter_connection_opts is called when production alter_connection_opts is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_connection_opts(ctx *Alter_connection_optsContext) {} + +// ExitAlter_connection_opts is called when production alter_connection_opts is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_connection_opts(ctx *Alter_connection_optsContext) {} + +// EnterAlter_user_opts is called when production alter_user_opts is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_user_opts(ctx *Alter_user_optsContext) {} + +// ExitAlter_user_opts is called when production alter_user_opts is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_user_opts(ctx *Alter_user_optsContext) {} + +// EnterAlter_tag_opts is called when production alter_tag_opts is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_tag_opts(ctx *Alter_tag_optsContext) {} + +// ExitAlter_tag_opts is called when production alter_tag_opts is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_tag_opts(ctx *Alter_tag_optsContext) {} + +// EnterAlter_network_policy_opts is called when production alter_network_policy_opts is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_network_policy_opts(ctx *Alter_network_policy_optsContext) { +} + +// ExitAlter_network_policy_opts is called when production alter_network_policy_opts is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_network_policy_opts(ctx *Alter_network_policy_optsContext) { +} + +// EnterAlter_warehouse_opts is called when production alter_warehouse_opts is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_warehouse_opts(ctx *Alter_warehouse_optsContext) {} + +// ExitAlter_warehouse_opts is called when production alter_warehouse_opts is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_warehouse_opts(ctx *Alter_warehouse_optsContext) {} + +// EnterAlter_account_opts is called when production alter_account_opts is entered. +func (s *BaseSnowflakeParserListener) EnterAlter_account_opts(ctx *Alter_account_optsContext) {} + +// ExitAlter_account_opts is called when production alter_account_opts is exited. +func (s *BaseSnowflakeParserListener) ExitAlter_account_opts(ctx *Alter_account_optsContext) {} + +// EnterSet_tags is called when production set_tags is entered. +func (s *BaseSnowflakeParserListener) EnterSet_tags(ctx *Set_tagsContext) {} + +// ExitSet_tags is called when production set_tags is exited. +func (s *BaseSnowflakeParserListener) ExitSet_tags(ctx *Set_tagsContext) {} + +// EnterTag_decl_list is called when production tag_decl_list is entered. +func (s *BaseSnowflakeParserListener) EnterTag_decl_list(ctx *Tag_decl_listContext) {} + +// ExitTag_decl_list is called when production tag_decl_list is exited. +func (s *BaseSnowflakeParserListener) ExitTag_decl_list(ctx *Tag_decl_listContext) {} + +// EnterUnset_tags is called when production unset_tags is entered. +func (s *BaseSnowflakeParserListener) EnterUnset_tags(ctx *Unset_tagsContext) {} + +// ExitUnset_tags is called when production unset_tags is exited. +func (s *BaseSnowflakeParserListener) ExitUnset_tags(ctx *Unset_tagsContext) {} + +// EnterCreate_command is called when production create_command is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_command(ctx *Create_commandContext) {} + +// ExitCreate_command is called when production create_command is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_command(ctx *Create_commandContext) {} + +// EnterCreate_account is called when production create_account is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_account(ctx *Create_accountContext) {} + +// ExitCreate_account is called when production create_account is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_account(ctx *Create_accountContext) {} + +// EnterCreate_alert is called when production create_alert is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_alert(ctx *Create_alertContext) {} + +// ExitCreate_alert is called when production create_alert is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_alert(ctx *Create_alertContext) {} + +// EnterAlert_condition is called when production alert_condition is entered. +func (s *BaseSnowflakeParserListener) EnterAlert_condition(ctx *Alert_conditionContext) {} + +// ExitAlert_condition is called when production alert_condition is exited. +func (s *BaseSnowflakeParserListener) ExitAlert_condition(ctx *Alert_conditionContext) {} + +// EnterAlert_action is called when production alert_action is entered. +func (s *BaseSnowflakeParserListener) EnterAlert_action(ctx *Alert_actionContext) {} + +// ExitAlert_action is called when production alert_action is exited. +func (s *BaseSnowflakeParserListener) ExitAlert_action(ctx *Alert_actionContext) {} + +// EnterCreate_api_integration is called when production create_api_integration is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_api_integration(ctx *Create_api_integrationContext) { +} + +// ExitCreate_api_integration is called when production create_api_integration is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_api_integration(ctx *Create_api_integrationContext) { +} + +// EnterCreate_object_clone is called when production create_object_clone is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_object_clone(ctx *Create_object_cloneContext) {} + +// ExitCreate_object_clone is called when production create_object_clone is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_object_clone(ctx *Create_object_cloneContext) {} + +// EnterCreate_connection is called when production create_connection is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_connection(ctx *Create_connectionContext) {} + +// ExitCreate_connection is called when production create_connection is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_connection(ctx *Create_connectionContext) {} + +// EnterCreate_database is called when production create_database is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_database(ctx *Create_databaseContext) {} + +// ExitCreate_database is called when production create_database is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_database(ctx *Create_databaseContext) {} + +// EnterCreate_dynamic_table is called when production create_dynamic_table is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_dynamic_table(ctx *Create_dynamic_tableContext) {} + +// ExitCreate_dynamic_table is called when production create_dynamic_table is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_dynamic_table(ctx *Create_dynamic_tableContext) {} + +// EnterClone_at_before is called when production clone_at_before is entered. +func (s *BaseSnowflakeParserListener) EnterClone_at_before(ctx *Clone_at_beforeContext) {} + +// ExitClone_at_before is called when production clone_at_before is exited. +func (s *BaseSnowflakeParserListener) ExitClone_at_before(ctx *Clone_at_beforeContext) {} + +// EnterAt_before1 is called when production at_before1 is entered. +func (s *BaseSnowflakeParserListener) EnterAt_before1(ctx *At_before1Context) {} + +// ExitAt_before1 is called when production at_before1 is exited. +func (s *BaseSnowflakeParserListener) ExitAt_before1(ctx *At_before1Context) {} + +// EnterHeader_decl is called when production header_decl is entered. +func (s *BaseSnowflakeParserListener) EnterHeader_decl(ctx *Header_declContext) {} + +// ExitHeader_decl is called when production header_decl is exited. +func (s *BaseSnowflakeParserListener) ExitHeader_decl(ctx *Header_declContext) {} + +// EnterCompression_type is called when production compression_type is entered. +func (s *BaseSnowflakeParserListener) EnterCompression_type(ctx *Compression_typeContext) {} + +// ExitCompression_type is called when production compression_type is exited. +func (s *BaseSnowflakeParserListener) ExitCompression_type(ctx *Compression_typeContext) {} + +// EnterCompression is called when production compression is entered. +func (s *BaseSnowflakeParserListener) EnterCompression(ctx *CompressionContext) {} + +// ExitCompression is called when production compression is exited. +func (s *BaseSnowflakeParserListener) ExitCompression(ctx *CompressionContext) {} + +// EnterCreate_external_function is called when production create_external_function is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_external_function(ctx *Create_external_functionContext) { +} + +// ExitCreate_external_function is called when production create_external_function is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_external_function(ctx *Create_external_functionContext) { +} + +// EnterCreate_external_table is called when production create_external_table is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_external_table(ctx *Create_external_tableContext) {} + +// ExitCreate_external_table is called when production create_external_table is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_external_table(ctx *Create_external_tableContext) {} + +// EnterExternal_table_column_decl is called when production external_table_column_decl is entered. +func (s *BaseSnowflakeParserListener) EnterExternal_table_column_decl(ctx *External_table_column_declContext) { +} + +// ExitExternal_table_column_decl is called when production external_table_column_decl is exited. +func (s *BaseSnowflakeParserListener) ExitExternal_table_column_decl(ctx *External_table_column_declContext) { +} + +// EnterExternal_table_column_decl_list is called when production external_table_column_decl_list is entered. +func (s *BaseSnowflakeParserListener) EnterExternal_table_column_decl_list(ctx *External_table_column_decl_listContext) { +} + +// ExitExternal_table_column_decl_list is called when production external_table_column_decl_list is exited. +func (s *BaseSnowflakeParserListener) ExitExternal_table_column_decl_list(ctx *External_table_column_decl_listContext) { +} + +// EnterFull_acct is called when production full_acct is entered. +func (s *BaseSnowflakeParserListener) EnterFull_acct(ctx *Full_acctContext) {} + +// ExitFull_acct is called when production full_acct is exited. +func (s *BaseSnowflakeParserListener) ExitFull_acct(ctx *Full_acctContext) {} + +// EnterIntegration_type_name is called when production integration_type_name is entered. +func (s *BaseSnowflakeParserListener) EnterIntegration_type_name(ctx *Integration_type_nameContext) {} + +// ExitIntegration_type_name is called when production integration_type_name is exited. +func (s *BaseSnowflakeParserListener) ExitIntegration_type_name(ctx *Integration_type_nameContext) {} + +// EnterCreate_failover_group is called when production create_failover_group is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_failover_group(ctx *Create_failover_groupContext) {} + +// ExitCreate_failover_group is called when production create_failover_group is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_failover_group(ctx *Create_failover_groupContext) {} + +// EnterType_fileformat is called when production type_fileformat is entered. +func (s *BaseSnowflakeParserListener) EnterType_fileformat(ctx *Type_fileformatContext) {} + +// ExitType_fileformat is called when production type_fileformat is exited. +func (s *BaseSnowflakeParserListener) ExitType_fileformat(ctx *Type_fileformatContext) {} + +// EnterCreate_file_format is called when production create_file_format is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_file_format(ctx *Create_file_formatContext) {} + +// ExitCreate_file_format is called when production create_file_format is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_file_format(ctx *Create_file_formatContext) {} + +// EnterArg_decl is called when production arg_decl is entered. +func (s *BaseSnowflakeParserListener) EnterArg_decl(ctx *Arg_declContext) {} + +// ExitArg_decl is called when production arg_decl is exited. +func (s *BaseSnowflakeParserListener) ExitArg_decl(ctx *Arg_declContext) {} + +// EnterCol_decl is called when production col_decl is entered. +func (s *BaseSnowflakeParserListener) EnterCol_decl(ctx *Col_declContext) {} + +// ExitCol_decl is called when production col_decl is exited. +func (s *BaseSnowflakeParserListener) ExitCol_decl(ctx *Col_declContext) {} + +// EnterFunction_definition is called when production function_definition is entered. +func (s *BaseSnowflakeParserListener) EnterFunction_definition(ctx *Function_definitionContext) {} + +// ExitFunction_definition is called when production function_definition is exited. +func (s *BaseSnowflakeParserListener) ExitFunction_definition(ctx *Function_definitionContext) {} + +// EnterCreate_function is called when production create_function is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_function(ctx *Create_functionContext) {} + +// ExitCreate_function is called when production create_function is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_function(ctx *Create_functionContext) {} + +// EnterCreate_managed_account is called when production create_managed_account is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_managed_account(ctx *Create_managed_accountContext) { +} + +// ExitCreate_managed_account is called when production create_managed_account is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_managed_account(ctx *Create_managed_accountContext) { +} + +// EnterCreate_masking_policy is called when production create_masking_policy is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_masking_policy(ctx *Create_masking_policyContext) {} + +// ExitCreate_masking_policy is called when production create_masking_policy is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_masking_policy(ctx *Create_masking_policyContext) {} + +// EnterTag_decl is called when production tag_decl is entered. +func (s *BaseSnowflakeParserListener) EnterTag_decl(ctx *Tag_declContext) {} + +// ExitTag_decl is called when production tag_decl is exited. +func (s *BaseSnowflakeParserListener) ExitTag_decl(ctx *Tag_declContext) {} + +// EnterColumn_list_in_parentheses is called when production column_list_in_parentheses is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_list_in_parentheses(ctx *Column_list_in_parenthesesContext) { +} + +// ExitColumn_list_in_parentheses is called when production column_list_in_parentheses is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_list_in_parentheses(ctx *Column_list_in_parenthesesContext) { +} + +// EnterCreate_materialized_view is called when production create_materialized_view is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_materialized_view(ctx *Create_materialized_viewContext) { +} + +// ExitCreate_materialized_view is called when production create_materialized_view is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_materialized_view(ctx *Create_materialized_viewContext) { +} + +// EnterCreate_network_policy is called when production create_network_policy is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_network_policy(ctx *Create_network_policyContext) {} + +// ExitCreate_network_policy is called when production create_network_policy is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_network_policy(ctx *Create_network_policyContext) {} + +// EnterCloud_provider_params_auto is called when production cloud_provider_params_auto is entered. +func (s *BaseSnowflakeParserListener) EnterCloud_provider_params_auto(ctx *Cloud_provider_params_autoContext) { +} + +// ExitCloud_provider_params_auto is called when production cloud_provider_params_auto is exited. +func (s *BaseSnowflakeParserListener) ExitCloud_provider_params_auto(ctx *Cloud_provider_params_autoContext) { +} + +// EnterCloud_provider_params_push is called when production cloud_provider_params_push is entered. +func (s *BaseSnowflakeParserListener) EnterCloud_provider_params_push(ctx *Cloud_provider_params_pushContext) { +} + +// ExitCloud_provider_params_push is called when production cloud_provider_params_push is exited. +func (s *BaseSnowflakeParserListener) ExitCloud_provider_params_push(ctx *Cloud_provider_params_pushContext) { +} + +// EnterCreate_notification_integration is called when production create_notification_integration is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_notification_integration(ctx *Create_notification_integrationContext) { +} + +// ExitCreate_notification_integration is called when production create_notification_integration is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_notification_integration(ctx *Create_notification_integrationContext) { +} + +// EnterCreate_pipe is called when production create_pipe is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_pipe(ctx *Create_pipeContext) {} + +// ExitCreate_pipe is called when production create_pipe is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_pipe(ctx *Create_pipeContext) {} + +// EnterCaller_owner is called when production caller_owner is entered. +func (s *BaseSnowflakeParserListener) EnterCaller_owner(ctx *Caller_ownerContext) {} + +// ExitCaller_owner is called when production caller_owner is exited. +func (s *BaseSnowflakeParserListener) ExitCaller_owner(ctx *Caller_ownerContext) {} + +// EnterExecuta_as is called when production executa_as is entered. +func (s *BaseSnowflakeParserListener) EnterExecuta_as(ctx *Executa_asContext) {} + +// ExitExecuta_as is called when production executa_as is exited. +func (s *BaseSnowflakeParserListener) ExitExecuta_as(ctx *Executa_asContext) {} + +// EnterProcedure_definition is called when production procedure_definition is entered. +func (s *BaseSnowflakeParserListener) EnterProcedure_definition(ctx *Procedure_definitionContext) {} + +// ExitProcedure_definition is called when production procedure_definition is exited. +func (s *BaseSnowflakeParserListener) ExitProcedure_definition(ctx *Procedure_definitionContext) {} + +// EnterCreate_procedure is called when production create_procedure is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_procedure(ctx *Create_procedureContext) {} + +// ExitCreate_procedure is called when production create_procedure is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_procedure(ctx *Create_procedureContext) {} + +// EnterCreate_replication_group is called when production create_replication_group is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_replication_group(ctx *Create_replication_groupContext) { +} + +// ExitCreate_replication_group is called when production create_replication_group is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_replication_group(ctx *Create_replication_groupContext) { +} + +// EnterCreate_resource_monitor is called when production create_resource_monitor is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_resource_monitor(ctx *Create_resource_monitorContext) { +} + +// ExitCreate_resource_monitor is called when production create_resource_monitor is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_resource_monitor(ctx *Create_resource_monitorContext) { +} + +// EnterCreate_role is called when production create_role is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_role(ctx *Create_roleContext) {} + +// ExitCreate_role is called when production create_role is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_role(ctx *Create_roleContext) {} + +// EnterCreate_row_access_policy is called when production create_row_access_policy is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_row_access_policy(ctx *Create_row_access_policyContext) { +} + +// ExitCreate_row_access_policy is called when production create_row_access_policy is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_row_access_policy(ctx *Create_row_access_policyContext) { +} + +// EnterCreate_schema is called when production create_schema is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_schema(ctx *Create_schemaContext) {} + +// ExitCreate_schema is called when production create_schema is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_schema(ctx *Create_schemaContext) {} + +// EnterCreate_security_integration_external_oauth is called when production create_security_integration_external_oauth is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_security_integration_external_oauth(ctx *Create_security_integration_external_oauthContext) { +} + +// ExitCreate_security_integration_external_oauth is called when production create_security_integration_external_oauth is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_security_integration_external_oauth(ctx *Create_security_integration_external_oauthContext) { +} + +// EnterImplicit_none is called when production implicit_none is entered. +func (s *BaseSnowflakeParserListener) EnterImplicit_none(ctx *Implicit_noneContext) {} + +// ExitImplicit_none is called when production implicit_none is exited. +func (s *BaseSnowflakeParserListener) ExitImplicit_none(ctx *Implicit_noneContext) {} + +// EnterCreate_security_integration_snowflake_oauth is called when production create_security_integration_snowflake_oauth is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_security_integration_snowflake_oauth(ctx *Create_security_integration_snowflake_oauthContext) { +} + +// ExitCreate_security_integration_snowflake_oauth is called when production create_security_integration_snowflake_oauth is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_security_integration_snowflake_oauth(ctx *Create_security_integration_snowflake_oauthContext) { +} + +// EnterCreate_security_integration_saml2 is called when production create_security_integration_saml2 is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_security_integration_saml2(ctx *Create_security_integration_saml2Context) { +} + +// ExitCreate_security_integration_saml2 is called when production create_security_integration_saml2 is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_security_integration_saml2(ctx *Create_security_integration_saml2Context) { +} + +// EnterCreate_security_integration_scim is called when production create_security_integration_scim is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_security_integration_scim(ctx *Create_security_integration_scimContext) { +} + +// ExitCreate_security_integration_scim is called when production create_security_integration_scim is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_security_integration_scim(ctx *Create_security_integration_scimContext) { +} + +// EnterNetwork_policy is called when production network_policy is entered. +func (s *BaseSnowflakeParserListener) EnterNetwork_policy(ctx *Network_policyContext) {} + +// ExitNetwork_policy is called when production network_policy is exited. +func (s *BaseSnowflakeParserListener) ExitNetwork_policy(ctx *Network_policyContext) {} + +// EnterPartner_application is called when production partner_application is entered. +func (s *BaseSnowflakeParserListener) EnterPartner_application(ctx *Partner_applicationContext) {} + +// ExitPartner_application is called when production partner_application is exited. +func (s *BaseSnowflakeParserListener) ExitPartner_application(ctx *Partner_applicationContext) {} + +// EnterStart_with is called when production start_with is entered. +func (s *BaseSnowflakeParserListener) EnterStart_with(ctx *Start_withContext) {} + +// ExitStart_with is called when production start_with is exited. +func (s *BaseSnowflakeParserListener) ExitStart_with(ctx *Start_withContext) {} + +// EnterIncrement_by is called when production increment_by is entered. +func (s *BaseSnowflakeParserListener) EnterIncrement_by(ctx *Increment_byContext) {} + +// ExitIncrement_by is called when production increment_by is exited. +func (s *BaseSnowflakeParserListener) ExitIncrement_by(ctx *Increment_byContext) {} + +// EnterCreate_sequence is called when production create_sequence is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_sequence(ctx *Create_sequenceContext) {} + +// ExitCreate_sequence is called when production create_sequence is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_sequence(ctx *Create_sequenceContext) {} + +// EnterCreate_session_policy is called when production create_session_policy is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_session_policy(ctx *Create_session_policyContext) {} + +// ExitCreate_session_policy is called when production create_session_policy is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_session_policy(ctx *Create_session_policyContext) {} + +// EnterCreate_share is called when production create_share is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_share(ctx *Create_shareContext) {} + +// ExitCreate_share is called when production create_share is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_share(ctx *Create_shareContext) {} + +// EnterCharacter is called when production character is entered. +func (s *BaseSnowflakeParserListener) EnterCharacter(ctx *CharacterContext) {} + +// ExitCharacter is called when production character is exited. +func (s *BaseSnowflakeParserListener) ExitCharacter(ctx *CharacterContext) {} + +// EnterFormat_type_options is called when production format_type_options is entered. +func (s *BaseSnowflakeParserListener) EnterFormat_type_options(ctx *Format_type_optionsContext) {} + +// ExitFormat_type_options is called when production format_type_options is exited. +func (s *BaseSnowflakeParserListener) ExitFormat_type_options(ctx *Format_type_optionsContext) {} + +// EnterCopy_options is called when production copy_options is entered. +func (s *BaseSnowflakeParserListener) EnterCopy_options(ctx *Copy_optionsContext) {} + +// ExitCopy_options is called when production copy_options is exited. +func (s *BaseSnowflakeParserListener) ExitCopy_options(ctx *Copy_optionsContext) {} + +// EnterInternal_stage_params is called when production internal_stage_params is entered. +func (s *BaseSnowflakeParserListener) EnterInternal_stage_params(ctx *Internal_stage_paramsContext) {} + +// ExitInternal_stage_params is called when production internal_stage_params is exited. +func (s *BaseSnowflakeParserListener) ExitInternal_stage_params(ctx *Internal_stage_paramsContext) {} + +// EnterStage_type is called when production stage_type is entered. +func (s *BaseSnowflakeParserListener) EnterStage_type(ctx *Stage_typeContext) {} + +// ExitStage_type is called when production stage_type is exited. +func (s *BaseSnowflakeParserListener) ExitStage_type(ctx *Stage_typeContext) {} + +// EnterStage_master_key is called when production stage_master_key is entered. +func (s *BaseSnowflakeParserListener) EnterStage_master_key(ctx *Stage_master_keyContext) {} + +// ExitStage_master_key is called when production stage_master_key is exited. +func (s *BaseSnowflakeParserListener) ExitStage_master_key(ctx *Stage_master_keyContext) {} + +// EnterStage_kms_key is called when production stage_kms_key is entered. +func (s *BaseSnowflakeParserListener) EnterStage_kms_key(ctx *Stage_kms_keyContext) {} + +// ExitStage_kms_key is called when production stage_kms_key is exited. +func (s *BaseSnowflakeParserListener) ExitStage_kms_key(ctx *Stage_kms_keyContext) {} + +// EnterStage_encryption_opts_aws is called when production stage_encryption_opts_aws is entered. +func (s *BaseSnowflakeParserListener) EnterStage_encryption_opts_aws(ctx *Stage_encryption_opts_awsContext) { +} + +// ExitStage_encryption_opts_aws is called when production stage_encryption_opts_aws is exited. +func (s *BaseSnowflakeParserListener) ExitStage_encryption_opts_aws(ctx *Stage_encryption_opts_awsContext) { +} + +// EnterAws_token is called when production aws_token is entered. +func (s *BaseSnowflakeParserListener) EnterAws_token(ctx *Aws_tokenContext) {} + +// ExitAws_token is called when production aws_token is exited. +func (s *BaseSnowflakeParserListener) ExitAws_token(ctx *Aws_tokenContext) {} + +// EnterAws_key_id is called when production aws_key_id is entered. +func (s *BaseSnowflakeParserListener) EnterAws_key_id(ctx *Aws_key_idContext) {} + +// ExitAws_key_id is called when production aws_key_id is exited. +func (s *BaseSnowflakeParserListener) ExitAws_key_id(ctx *Aws_key_idContext) {} + +// EnterAws_secret_key is called when production aws_secret_key is entered. +func (s *BaseSnowflakeParserListener) EnterAws_secret_key(ctx *Aws_secret_keyContext) {} + +// ExitAws_secret_key is called when production aws_secret_key is exited. +func (s *BaseSnowflakeParserListener) ExitAws_secret_key(ctx *Aws_secret_keyContext) {} + +// EnterAws_role is called when production aws_role is entered. +func (s *BaseSnowflakeParserListener) EnterAws_role(ctx *Aws_roleContext) {} + +// ExitAws_role is called when production aws_role is exited. +func (s *BaseSnowflakeParserListener) ExitAws_role(ctx *Aws_roleContext) {} + +// EnterExternal_stage_params is called when production external_stage_params is entered. +func (s *BaseSnowflakeParserListener) EnterExternal_stage_params(ctx *External_stage_paramsContext) {} + +// ExitExternal_stage_params is called when production external_stage_params is exited. +func (s *BaseSnowflakeParserListener) ExitExternal_stage_params(ctx *External_stage_paramsContext) {} + +// EnterTrue_false is called when production true_false is entered. +func (s *BaseSnowflakeParserListener) EnterTrue_false(ctx *True_falseContext) {} + +// ExitTrue_false is called when production true_false is exited. +func (s *BaseSnowflakeParserListener) ExitTrue_false(ctx *True_falseContext) {} + +// EnterEnable is called when production enable is entered. +func (s *BaseSnowflakeParserListener) EnterEnable(ctx *EnableContext) {} + +// ExitEnable is called when production enable is exited. +func (s *BaseSnowflakeParserListener) ExitEnable(ctx *EnableContext) {} + +// EnterRefresh_on_create is called when production refresh_on_create is entered. +func (s *BaseSnowflakeParserListener) EnterRefresh_on_create(ctx *Refresh_on_createContext) {} + +// ExitRefresh_on_create is called when production refresh_on_create is exited. +func (s *BaseSnowflakeParserListener) ExitRefresh_on_create(ctx *Refresh_on_createContext) {} + +// EnterAuto_refresh is called when production auto_refresh is entered. +func (s *BaseSnowflakeParserListener) EnterAuto_refresh(ctx *Auto_refreshContext) {} + +// ExitAuto_refresh is called when production auto_refresh is exited. +func (s *BaseSnowflakeParserListener) ExitAuto_refresh(ctx *Auto_refreshContext) {} + +// EnterNotification_integration is called when production notification_integration is entered. +func (s *BaseSnowflakeParserListener) EnterNotification_integration(ctx *Notification_integrationContext) { +} + +// ExitNotification_integration is called when production notification_integration is exited. +func (s *BaseSnowflakeParserListener) ExitNotification_integration(ctx *Notification_integrationContext) { +} + +// EnterDirectory_table_params is called when production directory_table_params is entered. +func (s *BaseSnowflakeParserListener) EnterDirectory_table_params(ctx *Directory_table_paramsContext) { +} + +// ExitDirectory_table_params is called when production directory_table_params is exited. +func (s *BaseSnowflakeParserListener) ExitDirectory_table_params(ctx *Directory_table_paramsContext) { +} + +// EnterCreate_stage is called when production create_stage is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_stage(ctx *Create_stageContext) {} + +// ExitCreate_stage is called when production create_stage is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_stage(ctx *Create_stageContext) {} + +// EnterCloud_provider_params is called when production cloud_provider_params is entered. +func (s *BaseSnowflakeParserListener) EnterCloud_provider_params(ctx *Cloud_provider_paramsContext) {} + +// ExitCloud_provider_params is called when production cloud_provider_params is exited. +func (s *BaseSnowflakeParserListener) ExitCloud_provider_params(ctx *Cloud_provider_paramsContext) {} + +// EnterCloud_provider_params2 is called when production cloud_provider_params2 is entered. +func (s *BaseSnowflakeParserListener) EnterCloud_provider_params2(ctx *Cloud_provider_params2Context) { +} + +// ExitCloud_provider_params2 is called when production cloud_provider_params2 is exited. +func (s *BaseSnowflakeParserListener) ExitCloud_provider_params2(ctx *Cloud_provider_params2Context) { +} + +// EnterCloud_provider_params3 is called when production cloud_provider_params3 is entered. +func (s *BaseSnowflakeParserListener) EnterCloud_provider_params3(ctx *Cloud_provider_params3Context) { +} + +// ExitCloud_provider_params3 is called when production cloud_provider_params3 is exited. +func (s *BaseSnowflakeParserListener) ExitCloud_provider_params3(ctx *Cloud_provider_params3Context) { +} + +// EnterCreate_storage_integration is called when production create_storage_integration is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_storage_integration(ctx *Create_storage_integrationContext) { +} + +// ExitCreate_storage_integration is called when production create_storage_integration is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_storage_integration(ctx *Create_storage_integrationContext) { +} + +// EnterCopy_grants is called when production copy_grants is entered. +func (s *BaseSnowflakeParserListener) EnterCopy_grants(ctx *Copy_grantsContext) {} + +// ExitCopy_grants is called when production copy_grants is exited. +func (s *BaseSnowflakeParserListener) ExitCopy_grants(ctx *Copy_grantsContext) {} + +// EnterAppend_only is called when production append_only is entered. +func (s *BaseSnowflakeParserListener) EnterAppend_only(ctx *Append_onlyContext) {} + +// ExitAppend_only is called when production append_only is exited. +func (s *BaseSnowflakeParserListener) ExitAppend_only(ctx *Append_onlyContext) {} + +// EnterInsert_only is called when production insert_only is entered. +func (s *BaseSnowflakeParserListener) EnterInsert_only(ctx *Insert_onlyContext) {} + +// ExitInsert_only is called when production insert_only is exited. +func (s *BaseSnowflakeParserListener) ExitInsert_only(ctx *Insert_onlyContext) {} + +// EnterShow_initial_rows is called when production show_initial_rows is entered. +func (s *BaseSnowflakeParserListener) EnterShow_initial_rows(ctx *Show_initial_rowsContext) {} + +// ExitShow_initial_rows is called when production show_initial_rows is exited. +func (s *BaseSnowflakeParserListener) ExitShow_initial_rows(ctx *Show_initial_rowsContext) {} + +// EnterStream_time is called when production stream_time is entered. +func (s *BaseSnowflakeParserListener) EnterStream_time(ctx *Stream_timeContext) {} + +// ExitStream_time is called when production stream_time is exited. +func (s *BaseSnowflakeParserListener) ExitStream_time(ctx *Stream_timeContext) {} + +// EnterCreate_stream is called when production create_stream is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_stream(ctx *Create_streamContext) {} + +// ExitCreate_stream is called when production create_stream is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_stream(ctx *Create_streamContext) {} + +// EnterTemporary is called when production temporary is entered. +func (s *BaseSnowflakeParserListener) EnterTemporary(ctx *TemporaryContext) {} + +// ExitTemporary is called when production temporary is exited. +func (s *BaseSnowflakeParserListener) ExitTemporary(ctx *TemporaryContext) {} + +// EnterTable_type is called when production table_type is entered. +func (s *BaseSnowflakeParserListener) EnterTable_type(ctx *Table_typeContext) {} + +// ExitTable_type is called when production table_type is exited. +func (s *BaseSnowflakeParserListener) ExitTable_type(ctx *Table_typeContext) {} + +// EnterWith_tags is called when production with_tags is entered. +func (s *BaseSnowflakeParserListener) EnterWith_tags(ctx *With_tagsContext) {} + +// ExitWith_tags is called when production with_tags is exited. +func (s *BaseSnowflakeParserListener) ExitWith_tags(ctx *With_tagsContext) {} + +// EnterWith_row_access_policy is called when production with_row_access_policy is entered. +func (s *BaseSnowflakeParserListener) EnterWith_row_access_policy(ctx *With_row_access_policyContext) { +} + +// ExitWith_row_access_policy is called when production with_row_access_policy is exited. +func (s *BaseSnowflakeParserListener) ExitWith_row_access_policy(ctx *With_row_access_policyContext) { +} + +// EnterCluster_by is called when production cluster_by is entered. +func (s *BaseSnowflakeParserListener) EnterCluster_by(ctx *Cluster_byContext) {} + +// ExitCluster_by is called when production cluster_by is exited. +func (s *BaseSnowflakeParserListener) ExitCluster_by(ctx *Cluster_byContext) {} + +// EnterChange_tracking is called when production change_tracking is entered. +func (s *BaseSnowflakeParserListener) EnterChange_tracking(ctx *Change_trackingContext) {} + +// ExitChange_tracking is called when production change_tracking is exited. +func (s *BaseSnowflakeParserListener) ExitChange_tracking(ctx *Change_trackingContext) {} + +// EnterWith_masking_policy is called when production with_masking_policy is entered. +func (s *BaseSnowflakeParserListener) EnterWith_masking_policy(ctx *With_masking_policyContext) {} + +// ExitWith_masking_policy is called when production with_masking_policy is exited. +func (s *BaseSnowflakeParserListener) ExitWith_masking_policy(ctx *With_masking_policyContext) {} + +// EnterCollate is called when production collate is entered. +func (s *BaseSnowflakeParserListener) EnterCollate(ctx *CollateContext) {} + +// ExitCollate is called when production collate is exited. +func (s *BaseSnowflakeParserListener) ExitCollate(ctx *CollateContext) {} + +// EnterNot_null is called when production not_null is entered. +func (s *BaseSnowflakeParserListener) EnterNot_null(ctx *Not_nullContext) {} + +// ExitNot_null is called when production not_null is exited. +func (s *BaseSnowflakeParserListener) ExitNot_null(ctx *Not_nullContext) {} + +// EnterDefault_value is called when production default_value is entered. +func (s *BaseSnowflakeParserListener) EnterDefault_value(ctx *Default_valueContext) {} + +// ExitDefault_value is called when production default_value is exited. +func (s *BaseSnowflakeParserListener) ExitDefault_value(ctx *Default_valueContext) {} + +// EnterForeign_key is called when production foreign_key is entered. +func (s *BaseSnowflakeParserListener) EnterForeign_key(ctx *Foreign_keyContext) {} + +// ExitForeign_key is called when production foreign_key is exited. +func (s *BaseSnowflakeParserListener) ExitForeign_key(ctx *Foreign_keyContext) {} + +// EnterOut_of_line_constraint is called when production out_of_line_constraint is entered. +func (s *BaseSnowflakeParserListener) EnterOut_of_line_constraint(ctx *Out_of_line_constraintContext) { +} + +// ExitOut_of_line_constraint is called when production out_of_line_constraint is exited. +func (s *BaseSnowflakeParserListener) ExitOut_of_line_constraint(ctx *Out_of_line_constraintContext) { +} + +// EnterFull_col_decl is called when production full_col_decl is entered. +func (s *BaseSnowflakeParserListener) EnterFull_col_decl(ctx *Full_col_declContext) {} + +// ExitFull_col_decl is called when production full_col_decl is exited. +func (s *BaseSnowflakeParserListener) ExitFull_col_decl(ctx *Full_col_declContext) {} + +// EnterColumn_decl_item is called when production column_decl_item is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_decl_item(ctx *Column_decl_itemContext) {} + +// ExitColumn_decl_item is called when production column_decl_item is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_decl_item(ctx *Column_decl_itemContext) {} + +// EnterColumn_decl_item_list is called when production column_decl_item_list is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_decl_item_list(ctx *Column_decl_item_listContext) {} + +// ExitColumn_decl_item_list is called when production column_decl_item_list is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_decl_item_list(ctx *Column_decl_item_listContext) {} + +// EnterCreate_table is called when production create_table is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_table(ctx *Create_tableContext) {} + +// ExitCreate_table is called when production create_table is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_table(ctx *Create_tableContext) {} + +// EnterCreate_table_as_select is called when production create_table_as_select is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_table_as_select(ctx *Create_table_as_selectContext) { +} + +// ExitCreate_table_as_select is called when production create_table_as_select is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_table_as_select(ctx *Create_table_as_selectContext) { +} + +// EnterCreate_tag is called when production create_tag is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_tag(ctx *Create_tagContext) {} + +// ExitCreate_tag is called when production create_tag is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_tag(ctx *Create_tagContext) {} + +// EnterSession_parameter is called when production session_parameter is entered. +func (s *BaseSnowflakeParserListener) EnterSession_parameter(ctx *Session_parameterContext) {} + +// ExitSession_parameter is called when production session_parameter is exited. +func (s *BaseSnowflakeParserListener) ExitSession_parameter(ctx *Session_parameterContext) {} + +// EnterSession_parameter_list is called when production session_parameter_list is entered. +func (s *BaseSnowflakeParserListener) EnterSession_parameter_list(ctx *Session_parameter_listContext) { +} + +// ExitSession_parameter_list is called when production session_parameter_list is exited. +func (s *BaseSnowflakeParserListener) ExitSession_parameter_list(ctx *Session_parameter_listContext) { +} + +// EnterSession_parameter_init_list is called when production session_parameter_init_list is entered. +func (s *BaseSnowflakeParserListener) EnterSession_parameter_init_list(ctx *Session_parameter_init_listContext) { +} + +// ExitSession_parameter_init_list is called when production session_parameter_init_list is exited. +func (s *BaseSnowflakeParserListener) ExitSession_parameter_init_list(ctx *Session_parameter_init_listContext) { +} + +// EnterSession_parameter_init is called when production session_parameter_init is entered. +func (s *BaseSnowflakeParserListener) EnterSession_parameter_init(ctx *Session_parameter_initContext) { +} + +// ExitSession_parameter_init is called when production session_parameter_init is exited. +func (s *BaseSnowflakeParserListener) ExitSession_parameter_init(ctx *Session_parameter_initContext) { +} + +// EnterCreate_task is called when production create_task is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_task(ctx *Create_taskContext) {} + +// ExitCreate_task is called when production create_task is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_task(ctx *Create_taskContext) {} + +// EnterSql is called when production sql is entered. +func (s *BaseSnowflakeParserListener) EnterSql(ctx *SqlContext) {} + +// ExitSql is called when production sql is exited. +func (s *BaseSnowflakeParserListener) ExitSql(ctx *SqlContext) {} + +// EnterCall is called when production call is entered. +func (s *BaseSnowflakeParserListener) EnterCall(ctx *CallContext) {} + +// ExitCall is called when production call is exited. +func (s *BaseSnowflakeParserListener) ExitCall(ctx *CallContext) {} + +// EnterCreate_user is called when production create_user is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_user(ctx *Create_userContext) {} + +// ExitCreate_user is called when production create_user is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_user(ctx *Create_userContext) {} + +// EnterView_col is called when production view_col is entered. +func (s *BaseSnowflakeParserListener) EnterView_col(ctx *View_colContext) {} + +// ExitView_col is called when production view_col is exited. +func (s *BaseSnowflakeParserListener) ExitView_col(ctx *View_colContext) {} + +// EnterCreate_view is called when production create_view is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_view(ctx *Create_viewContext) {} + +// ExitCreate_view is called when production create_view is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_view(ctx *Create_viewContext) {} + +// EnterCreate_warehouse is called when production create_warehouse is entered. +func (s *BaseSnowflakeParserListener) EnterCreate_warehouse(ctx *Create_warehouseContext) {} + +// ExitCreate_warehouse is called when production create_warehouse is exited. +func (s *BaseSnowflakeParserListener) ExitCreate_warehouse(ctx *Create_warehouseContext) {} + +// EnterWh_properties is called when production wh_properties is entered. +func (s *BaseSnowflakeParserListener) EnterWh_properties(ctx *Wh_propertiesContext) {} + +// ExitWh_properties is called when production wh_properties is exited. +func (s *BaseSnowflakeParserListener) ExitWh_properties(ctx *Wh_propertiesContext) {} + +// EnterWh_params is called when production wh_params is entered. +func (s *BaseSnowflakeParserListener) EnterWh_params(ctx *Wh_paramsContext) {} + +// ExitWh_params is called when production wh_params is exited. +func (s *BaseSnowflakeParserListener) ExitWh_params(ctx *Wh_paramsContext) {} + +// EnterTrigger_definition is called when production trigger_definition is entered. +func (s *BaseSnowflakeParserListener) EnterTrigger_definition(ctx *Trigger_definitionContext) {} + +// ExitTrigger_definition is called when production trigger_definition is exited. +func (s *BaseSnowflakeParserListener) ExitTrigger_definition(ctx *Trigger_definitionContext) {} + +// EnterObject_type_name is called when production object_type_name is entered. +func (s *BaseSnowflakeParserListener) EnterObject_type_name(ctx *Object_type_nameContext) {} + +// ExitObject_type_name is called when production object_type_name is exited. +func (s *BaseSnowflakeParserListener) ExitObject_type_name(ctx *Object_type_nameContext) {} + +// EnterObject_type_plural is called when production object_type_plural is entered. +func (s *BaseSnowflakeParserListener) EnterObject_type_plural(ctx *Object_type_pluralContext) {} + +// ExitObject_type_plural is called when production object_type_plural is exited. +func (s *BaseSnowflakeParserListener) ExitObject_type_plural(ctx *Object_type_pluralContext) {} + +// EnterDrop_command is called when production drop_command is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_command(ctx *Drop_commandContext) {} + +// ExitDrop_command is called when production drop_command is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_command(ctx *Drop_commandContext) {} + +// EnterDrop_object is called when production drop_object is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_object(ctx *Drop_objectContext) {} + +// ExitDrop_object is called when production drop_object is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_object(ctx *Drop_objectContext) {} + +// EnterDrop_alert is called when production drop_alert is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_alert(ctx *Drop_alertContext) {} + +// ExitDrop_alert is called when production drop_alert is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_alert(ctx *Drop_alertContext) {} + +// EnterDrop_connection is called when production drop_connection is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_connection(ctx *Drop_connectionContext) {} + +// ExitDrop_connection is called when production drop_connection is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_connection(ctx *Drop_connectionContext) {} + +// EnterDrop_database is called when production drop_database is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_database(ctx *Drop_databaseContext) {} + +// ExitDrop_database is called when production drop_database is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_database(ctx *Drop_databaseContext) {} + +// EnterDrop_dynamic_table is called when production drop_dynamic_table is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_dynamic_table(ctx *Drop_dynamic_tableContext) {} + +// ExitDrop_dynamic_table is called when production drop_dynamic_table is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_dynamic_table(ctx *Drop_dynamic_tableContext) {} + +// EnterDrop_external_table is called when production drop_external_table is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_external_table(ctx *Drop_external_tableContext) {} + +// ExitDrop_external_table is called when production drop_external_table is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_external_table(ctx *Drop_external_tableContext) {} + +// EnterDrop_failover_group is called when production drop_failover_group is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_failover_group(ctx *Drop_failover_groupContext) {} + +// ExitDrop_failover_group is called when production drop_failover_group is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_failover_group(ctx *Drop_failover_groupContext) {} + +// EnterDrop_file_format is called when production drop_file_format is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_file_format(ctx *Drop_file_formatContext) {} + +// ExitDrop_file_format is called when production drop_file_format is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_file_format(ctx *Drop_file_formatContext) {} + +// EnterDrop_function is called when production drop_function is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_function(ctx *Drop_functionContext) {} + +// ExitDrop_function is called when production drop_function is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_function(ctx *Drop_functionContext) {} + +// EnterDrop_integration is called when production drop_integration is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_integration(ctx *Drop_integrationContext) {} + +// ExitDrop_integration is called when production drop_integration is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_integration(ctx *Drop_integrationContext) {} + +// EnterDrop_managed_account is called when production drop_managed_account is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_managed_account(ctx *Drop_managed_accountContext) {} + +// ExitDrop_managed_account is called when production drop_managed_account is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_managed_account(ctx *Drop_managed_accountContext) {} + +// EnterDrop_masking_policy is called when production drop_masking_policy is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_masking_policy(ctx *Drop_masking_policyContext) {} + +// ExitDrop_masking_policy is called when production drop_masking_policy is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_masking_policy(ctx *Drop_masking_policyContext) {} + +// EnterDrop_materialized_view is called when production drop_materialized_view is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_materialized_view(ctx *Drop_materialized_viewContext) { +} + +// ExitDrop_materialized_view is called when production drop_materialized_view is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_materialized_view(ctx *Drop_materialized_viewContext) { +} + +// EnterDrop_network_policy is called when production drop_network_policy is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_network_policy(ctx *Drop_network_policyContext) {} + +// ExitDrop_network_policy is called when production drop_network_policy is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_network_policy(ctx *Drop_network_policyContext) {} + +// EnterDrop_pipe is called when production drop_pipe is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_pipe(ctx *Drop_pipeContext) {} + +// ExitDrop_pipe is called when production drop_pipe is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_pipe(ctx *Drop_pipeContext) {} + +// EnterDrop_procedure is called when production drop_procedure is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_procedure(ctx *Drop_procedureContext) {} + +// ExitDrop_procedure is called when production drop_procedure is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_procedure(ctx *Drop_procedureContext) {} + +// EnterDrop_replication_group is called when production drop_replication_group is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_replication_group(ctx *Drop_replication_groupContext) { +} + +// ExitDrop_replication_group is called when production drop_replication_group is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_replication_group(ctx *Drop_replication_groupContext) { +} + +// EnterDrop_resource_monitor is called when production drop_resource_monitor is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_resource_monitor(ctx *Drop_resource_monitorContext) {} + +// ExitDrop_resource_monitor is called when production drop_resource_monitor is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_resource_monitor(ctx *Drop_resource_monitorContext) {} + +// EnterDrop_role is called when production drop_role is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_role(ctx *Drop_roleContext) {} + +// ExitDrop_role is called when production drop_role is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_role(ctx *Drop_roleContext) {} + +// EnterDrop_row_access_policy is called when production drop_row_access_policy is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_row_access_policy(ctx *Drop_row_access_policyContext) { +} + +// ExitDrop_row_access_policy is called when production drop_row_access_policy is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_row_access_policy(ctx *Drop_row_access_policyContext) { +} + +// EnterDrop_schema is called when production drop_schema is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_schema(ctx *Drop_schemaContext) {} + +// ExitDrop_schema is called when production drop_schema is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_schema(ctx *Drop_schemaContext) {} + +// EnterDrop_sequence is called when production drop_sequence is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_sequence(ctx *Drop_sequenceContext) {} + +// ExitDrop_sequence is called when production drop_sequence is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_sequence(ctx *Drop_sequenceContext) {} + +// EnterDrop_session_policy is called when production drop_session_policy is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_session_policy(ctx *Drop_session_policyContext) {} + +// ExitDrop_session_policy is called when production drop_session_policy is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_session_policy(ctx *Drop_session_policyContext) {} + +// EnterDrop_share is called when production drop_share is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_share(ctx *Drop_shareContext) {} + +// ExitDrop_share is called when production drop_share is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_share(ctx *Drop_shareContext) {} + +// EnterDrop_stage is called when production drop_stage is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_stage(ctx *Drop_stageContext) {} + +// ExitDrop_stage is called when production drop_stage is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_stage(ctx *Drop_stageContext) {} + +// EnterDrop_stream is called when production drop_stream is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_stream(ctx *Drop_streamContext) {} + +// ExitDrop_stream is called when production drop_stream is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_stream(ctx *Drop_streamContext) {} + +// EnterDrop_table is called when production drop_table is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_table(ctx *Drop_tableContext) {} + +// ExitDrop_table is called when production drop_table is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_table(ctx *Drop_tableContext) {} + +// EnterDrop_tag is called when production drop_tag is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_tag(ctx *Drop_tagContext) {} + +// ExitDrop_tag is called when production drop_tag is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_tag(ctx *Drop_tagContext) {} + +// EnterDrop_task is called when production drop_task is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_task(ctx *Drop_taskContext) {} + +// ExitDrop_task is called when production drop_task is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_task(ctx *Drop_taskContext) {} + +// EnterDrop_user is called when production drop_user is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_user(ctx *Drop_userContext) {} + +// ExitDrop_user is called when production drop_user is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_user(ctx *Drop_userContext) {} + +// EnterDrop_view is called when production drop_view is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_view(ctx *Drop_viewContext) {} + +// ExitDrop_view is called when production drop_view is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_view(ctx *Drop_viewContext) {} + +// EnterDrop_warehouse is called when production drop_warehouse is entered. +func (s *BaseSnowflakeParserListener) EnterDrop_warehouse(ctx *Drop_warehouseContext) {} + +// ExitDrop_warehouse is called when production drop_warehouse is exited. +func (s *BaseSnowflakeParserListener) ExitDrop_warehouse(ctx *Drop_warehouseContext) {} + +// EnterCascade_restrict is called when production cascade_restrict is entered. +func (s *BaseSnowflakeParserListener) EnterCascade_restrict(ctx *Cascade_restrictContext) {} + +// ExitCascade_restrict is called when production cascade_restrict is exited. +func (s *BaseSnowflakeParserListener) ExitCascade_restrict(ctx *Cascade_restrictContext) {} + +// EnterArg_types is called when production arg_types is entered. +func (s *BaseSnowflakeParserListener) EnterArg_types(ctx *Arg_typesContext) {} + +// ExitArg_types is called when production arg_types is exited. +func (s *BaseSnowflakeParserListener) ExitArg_types(ctx *Arg_typesContext) {} + +// EnterUndrop_command is called when production undrop_command is entered. +func (s *BaseSnowflakeParserListener) EnterUndrop_command(ctx *Undrop_commandContext) {} + +// ExitUndrop_command is called when production undrop_command is exited. +func (s *BaseSnowflakeParserListener) ExitUndrop_command(ctx *Undrop_commandContext) {} + +// EnterUndrop_database is called when production undrop_database is entered. +func (s *BaseSnowflakeParserListener) EnterUndrop_database(ctx *Undrop_databaseContext) {} + +// ExitUndrop_database is called when production undrop_database is exited. +func (s *BaseSnowflakeParserListener) ExitUndrop_database(ctx *Undrop_databaseContext) {} + +// EnterUndrop_dynamic_table is called when production undrop_dynamic_table is entered. +func (s *BaseSnowflakeParserListener) EnterUndrop_dynamic_table(ctx *Undrop_dynamic_tableContext) {} + +// ExitUndrop_dynamic_table is called when production undrop_dynamic_table is exited. +func (s *BaseSnowflakeParserListener) ExitUndrop_dynamic_table(ctx *Undrop_dynamic_tableContext) {} + +// EnterUndrop_schema is called when production undrop_schema is entered. +func (s *BaseSnowflakeParserListener) EnterUndrop_schema(ctx *Undrop_schemaContext) {} + +// ExitUndrop_schema is called when production undrop_schema is exited. +func (s *BaseSnowflakeParserListener) ExitUndrop_schema(ctx *Undrop_schemaContext) {} + +// EnterUndrop_table is called when production undrop_table is entered. +func (s *BaseSnowflakeParserListener) EnterUndrop_table(ctx *Undrop_tableContext) {} + +// ExitUndrop_table is called when production undrop_table is exited. +func (s *BaseSnowflakeParserListener) ExitUndrop_table(ctx *Undrop_tableContext) {} + +// EnterUndrop_tag is called when production undrop_tag is entered. +func (s *BaseSnowflakeParserListener) EnterUndrop_tag(ctx *Undrop_tagContext) {} + +// ExitUndrop_tag is called when production undrop_tag is exited. +func (s *BaseSnowflakeParserListener) ExitUndrop_tag(ctx *Undrop_tagContext) {} + +// EnterUse_command is called when production use_command is entered. +func (s *BaseSnowflakeParserListener) EnterUse_command(ctx *Use_commandContext) {} + +// ExitUse_command is called when production use_command is exited. +func (s *BaseSnowflakeParserListener) ExitUse_command(ctx *Use_commandContext) {} + +// EnterUse_database is called when production use_database is entered. +func (s *BaseSnowflakeParserListener) EnterUse_database(ctx *Use_databaseContext) {} + +// ExitUse_database is called when production use_database is exited. +func (s *BaseSnowflakeParserListener) ExitUse_database(ctx *Use_databaseContext) {} + +// EnterUse_role is called when production use_role is entered. +func (s *BaseSnowflakeParserListener) EnterUse_role(ctx *Use_roleContext) {} + +// ExitUse_role is called when production use_role is exited. +func (s *BaseSnowflakeParserListener) ExitUse_role(ctx *Use_roleContext) {} + +// EnterUse_schema is called when production use_schema is entered. +func (s *BaseSnowflakeParserListener) EnterUse_schema(ctx *Use_schemaContext) {} + +// ExitUse_schema is called when production use_schema is exited. +func (s *BaseSnowflakeParserListener) ExitUse_schema(ctx *Use_schemaContext) {} + +// EnterUse_secondary_roles is called when production use_secondary_roles is entered. +func (s *BaseSnowflakeParserListener) EnterUse_secondary_roles(ctx *Use_secondary_rolesContext) {} + +// ExitUse_secondary_roles is called when production use_secondary_roles is exited. +func (s *BaseSnowflakeParserListener) ExitUse_secondary_roles(ctx *Use_secondary_rolesContext) {} + +// EnterUse_warehouse is called when production use_warehouse is entered. +func (s *BaseSnowflakeParserListener) EnterUse_warehouse(ctx *Use_warehouseContext) {} + +// ExitUse_warehouse is called when production use_warehouse is exited. +func (s *BaseSnowflakeParserListener) ExitUse_warehouse(ctx *Use_warehouseContext) {} + +// EnterComment_clause is called when production comment_clause is entered. +func (s *BaseSnowflakeParserListener) EnterComment_clause(ctx *Comment_clauseContext) {} + +// ExitComment_clause is called when production comment_clause is exited. +func (s *BaseSnowflakeParserListener) ExitComment_clause(ctx *Comment_clauseContext) {} + +// EnterIf_suspended is called when production if_suspended is entered. +func (s *BaseSnowflakeParserListener) EnterIf_suspended(ctx *If_suspendedContext) {} + +// ExitIf_suspended is called when production if_suspended is exited. +func (s *BaseSnowflakeParserListener) ExitIf_suspended(ctx *If_suspendedContext) {} + +// EnterIf_exists is called when production if_exists is entered. +func (s *BaseSnowflakeParserListener) EnterIf_exists(ctx *If_existsContext) {} + +// ExitIf_exists is called when production if_exists is exited. +func (s *BaseSnowflakeParserListener) ExitIf_exists(ctx *If_existsContext) {} + +// EnterIf_not_exists is called when production if_not_exists is entered. +func (s *BaseSnowflakeParserListener) EnterIf_not_exists(ctx *If_not_existsContext) {} + +// ExitIf_not_exists is called when production if_not_exists is exited. +func (s *BaseSnowflakeParserListener) ExitIf_not_exists(ctx *If_not_existsContext) {} + +// EnterOr_replace is called when production or_replace is entered. +func (s *BaseSnowflakeParserListener) EnterOr_replace(ctx *Or_replaceContext) {} + +// ExitOr_replace is called when production or_replace is exited. +func (s *BaseSnowflakeParserListener) ExitOr_replace(ctx *Or_replaceContext) {} + +// EnterDescribe is called when production describe is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe(ctx *DescribeContext) {} + +// ExitDescribe is called when production describe is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe(ctx *DescribeContext) {} + +// EnterDescribe_command is called when production describe_command is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_command(ctx *Describe_commandContext) {} + +// ExitDescribe_command is called when production describe_command is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_command(ctx *Describe_commandContext) {} + +// EnterDescribe_alert is called when production describe_alert is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_alert(ctx *Describe_alertContext) {} + +// ExitDescribe_alert is called when production describe_alert is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_alert(ctx *Describe_alertContext) {} + +// EnterDescribe_database is called when production describe_database is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_database(ctx *Describe_databaseContext) {} + +// ExitDescribe_database is called when production describe_database is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_database(ctx *Describe_databaseContext) {} + +// EnterDescribe_dynamic_table is called when production describe_dynamic_table is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_dynamic_table(ctx *Describe_dynamic_tableContext) { +} + +// ExitDescribe_dynamic_table is called when production describe_dynamic_table is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_dynamic_table(ctx *Describe_dynamic_tableContext) { +} + +// EnterDescribe_external_table is called when production describe_external_table is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_external_table(ctx *Describe_external_tableContext) { +} + +// ExitDescribe_external_table is called when production describe_external_table is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_external_table(ctx *Describe_external_tableContext) { +} + +// EnterDescribe_file_format is called when production describe_file_format is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_file_format(ctx *Describe_file_formatContext) {} + +// ExitDescribe_file_format is called when production describe_file_format is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_file_format(ctx *Describe_file_formatContext) {} + +// EnterDescribe_function is called when production describe_function is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_function(ctx *Describe_functionContext) {} + +// ExitDescribe_function is called when production describe_function is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_function(ctx *Describe_functionContext) {} + +// EnterDescribe_integration is called when production describe_integration is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_integration(ctx *Describe_integrationContext) {} + +// ExitDescribe_integration is called when production describe_integration is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_integration(ctx *Describe_integrationContext) {} + +// EnterDescribe_masking_policy is called when production describe_masking_policy is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_masking_policy(ctx *Describe_masking_policyContext) { +} + +// ExitDescribe_masking_policy is called when production describe_masking_policy is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_masking_policy(ctx *Describe_masking_policyContext) { +} + +// EnterDescribe_materialized_view is called when production describe_materialized_view is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_materialized_view(ctx *Describe_materialized_viewContext) { +} + +// ExitDescribe_materialized_view is called when production describe_materialized_view is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_materialized_view(ctx *Describe_materialized_viewContext) { +} + +// EnterDescribe_network_policy is called when production describe_network_policy is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_network_policy(ctx *Describe_network_policyContext) { +} + +// ExitDescribe_network_policy is called when production describe_network_policy is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_network_policy(ctx *Describe_network_policyContext) { +} + +// EnterDescribe_pipe is called when production describe_pipe is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_pipe(ctx *Describe_pipeContext) {} + +// ExitDescribe_pipe is called when production describe_pipe is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_pipe(ctx *Describe_pipeContext) {} + +// EnterDescribe_procedure is called when production describe_procedure is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_procedure(ctx *Describe_procedureContext) {} + +// ExitDescribe_procedure is called when production describe_procedure is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_procedure(ctx *Describe_procedureContext) {} + +// EnterDescribe_result is called when production describe_result is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_result(ctx *Describe_resultContext) {} + +// ExitDescribe_result is called when production describe_result is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_result(ctx *Describe_resultContext) {} + +// EnterDescribe_row_access_policy is called when production describe_row_access_policy is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_row_access_policy(ctx *Describe_row_access_policyContext) { +} + +// ExitDescribe_row_access_policy is called when production describe_row_access_policy is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_row_access_policy(ctx *Describe_row_access_policyContext) { +} + +// EnterDescribe_schema is called when production describe_schema is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_schema(ctx *Describe_schemaContext) {} + +// ExitDescribe_schema is called when production describe_schema is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_schema(ctx *Describe_schemaContext) {} + +// EnterDescribe_search_optimization is called when production describe_search_optimization is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_search_optimization(ctx *Describe_search_optimizationContext) { +} + +// ExitDescribe_search_optimization is called when production describe_search_optimization is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_search_optimization(ctx *Describe_search_optimizationContext) { +} + +// EnterDescribe_sequence is called when production describe_sequence is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_sequence(ctx *Describe_sequenceContext) {} + +// ExitDescribe_sequence is called when production describe_sequence is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_sequence(ctx *Describe_sequenceContext) {} + +// EnterDescribe_session_policy is called when production describe_session_policy is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_session_policy(ctx *Describe_session_policyContext) { +} + +// ExitDescribe_session_policy is called when production describe_session_policy is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_session_policy(ctx *Describe_session_policyContext) { +} + +// EnterDescribe_share is called when production describe_share is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_share(ctx *Describe_shareContext) {} + +// ExitDescribe_share is called when production describe_share is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_share(ctx *Describe_shareContext) {} + +// EnterDescribe_stage is called when production describe_stage is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_stage(ctx *Describe_stageContext) {} + +// ExitDescribe_stage is called when production describe_stage is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_stage(ctx *Describe_stageContext) {} + +// EnterDescribe_stream is called when production describe_stream is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_stream(ctx *Describe_streamContext) {} + +// ExitDescribe_stream is called when production describe_stream is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_stream(ctx *Describe_streamContext) {} + +// EnterDescribe_table is called when production describe_table is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_table(ctx *Describe_tableContext) {} + +// ExitDescribe_table is called when production describe_table is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_table(ctx *Describe_tableContext) {} + +// EnterDescribe_task is called when production describe_task is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_task(ctx *Describe_taskContext) {} + +// ExitDescribe_task is called when production describe_task is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_task(ctx *Describe_taskContext) {} + +// EnterDescribe_transaction is called when production describe_transaction is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_transaction(ctx *Describe_transactionContext) {} + +// ExitDescribe_transaction is called when production describe_transaction is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_transaction(ctx *Describe_transactionContext) {} + +// EnterDescribe_user is called when production describe_user is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_user(ctx *Describe_userContext) {} + +// ExitDescribe_user is called when production describe_user is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_user(ctx *Describe_userContext) {} + +// EnterDescribe_view is called when production describe_view is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_view(ctx *Describe_viewContext) {} + +// ExitDescribe_view is called when production describe_view is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_view(ctx *Describe_viewContext) {} + +// EnterDescribe_warehouse is called when production describe_warehouse is entered. +func (s *BaseSnowflakeParserListener) EnterDescribe_warehouse(ctx *Describe_warehouseContext) {} + +// ExitDescribe_warehouse is called when production describe_warehouse is exited. +func (s *BaseSnowflakeParserListener) ExitDescribe_warehouse(ctx *Describe_warehouseContext) {} + +// EnterShow_command is called when production show_command is entered. +func (s *BaseSnowflakeParserListener) EnterShow_command(ctx *Show_commandContext) {} + +// ExitShow_command is called when production show_command is exited. +func (s *BaseSnowflakeParserListener) ExitShow_command(ctx *Show_commandContext) {} + +// EnterShow_alerts is called when production show_alerts is entered. +func (s *BaseSnowflakeParserListener) EnterShow_alerts(ctx *Show_alertsContext) {} + +// ExitShow_alerts is called when production show_alerts is exited. +func (s *BaseSnowflakeParserListener) ExitShow_alerts(ctx *Show_alertsContext) {} + +// EnterShow_columns is called when production show_columns is entered. +func (s *BaseSnowflakeParserListener) EnterShow_columns(ctx *Show_columnsContext) {} + +// ExitShow_columns is called when production show_columns is exited. +func (s *BaseSnowflakeParserListener) ExitShow_columns(ctx *Show_columnsContext) {} + +// EnterShow_connections is called when production show_connections is entered. +func (s *BaseSnowflakeParserListener) EnterShow_connections(ctx *Show_connectionsContext) {} + +// ExitShow_connections is called when production show_connections is exited. +func (s *BaseSnowflakeParserListener) ExitShow_connections(ctx *Show_connectionsContext) {} + +// EnterStarts_with is called when production starts_with is entered. +func (s *BaseSnowflakeParserListener) EnterStarts_with(ctx *Starts_withContext) {} + +// ExitStarts_with is called when production starts_with is exited. +func (s *BaseSnowflakeParserListener) ExitStarts_with(ctx *Starts_withContext) {} + +// EnterLimit_rows is called when production limit_rows is entered. +func (s *BaseSnowflakeParserListener) EnterLimit_rows(ctx *Limit_rowsContext) {} + +// ExitLimit_rows is called when production limit_rows is exited. +func (s *BaseSnowflakeParserListener) ExitLimit_rows(ctx *Limit_rowsContext) {} + +// EnterShow_databases is called when production show_databases is entered. +func (s *BaseSnowflakeParserListener) EnterShow_databases(ctx *Show_databasesContext) {} + +// ExitShow_databases is called when production show_databases is exited. +func (s *BaseSnowflakeParserListener) ExitShow_databases(ctx *Show_databasesContext) {} + +// EnterShow_databases_in_failover_group is called when production show_databases_in_failover_group is entered. +func (s *BaseSnowflakeParserListener) EnterShow_databases_in_failover_group(ctx *Show_databases_in_failover_groupContext) { +} + +// ExitShow_databases_in_failover_group is called when production show_databases_in_failover_group is exited. +func (s *BaseSnowflakeParserListener) ExitShow_databases_in_failover_group(ctx *Show_databases_in_failover_groupContext) { +} + +// EnterShow_databases_in_replication_group is called when production show_databases_in_replication_group is entered. +func (s *BaseSnowflakeParserListener) EnterShow_databases_in_replication_group(ctx *Show_databases_in_replication_groupContext) { +} + +// ExitShow_databases_in_replication_group is called when production show_databases_in_replication_group is exited. +func (s *BaseSnowflakeParserListener) ExitShow_databases_in_replication_group(ctx *Show_databases_in_replication_groupContext) { +} + +// EnterShow_delegated_authorizations is called when production show_delegated_authorizations is entered. +func (s *BaseSnowflakeParserListener) EnterShow_delegated_authorizations(ctx *Show_delegated_authorizationsContext) { +} + +// ExitShow_delegated_authorizations is called when production show_delegated_authorizations is exited. +func (s *BaseSnowflakeParserListener) ExitShow_delegated_authorizations(ctx *Show_delegated_authorizationsContext) { +} + +// EnterShow_external_functions is called when production show_external_functions is entered. +func (s *BaseSnowflakeParserListener) EnterShow_external_functions(ctx *Show_external_functionsContext) { +} + +// ExitShow_external_functions is called when production show_external_functions is exited. +func (s *BaseSnowflakeParserListener) ExitShow_external_functions(ctx *Show_external_functionsContext) { +} + +// EnterShow_dynamic_tables is called when production show_dynamic_tables is entered. +func (s *BaseSnowflakeParserListener) EnterShow_dynamic_tables(ctx *Show_dynamic_tablesContext) {} + +// ExitShow_dynamic_tables is called when production show_dynamic_tables is exited. +func (s *BaseSnowflakeParserListener) ExitShow_dynamic_tables(ctx *Show_dynamic_tablesContext) {} + +// EnterShow_external_tables is called when production show_external_tables is entered. +func (s *BaseSnowflakeParserListener) EnterShow_external_tables(ctx *Show_external_tablesContext) {} + +// ExitShow_external_tables is called when production show_external_tables is exited. +func (s *BaseSnowflakeParserListener) ExitShow_external_tables(ctx *Show_external_tablesContext) {} + +// EnterShow_failover_groups is called when production show_failover_groups is entered. +func (s *BaseSnowflakeParserListener) EnterShow_failover_groups(ctx *Show_failover_groupsContext) {} + +// ExitShow_failover_groups is called when production show_failover_groups is exited. +func (s *BaseSnowflakeParserListener) ExitShow_failover_groups(ctx *Show_failover_groupsContext) {} + +// EnterShow_file_formats is called when production show_file_formats is entered. +func (s *BaseSnowflakeParserListener) EnterShow_file_formats(ctx *Show_file_formatsContext) {} + +// ExitShow_file_formats is called when production show_file_formats is exited. +func (s *BaseSnowflakeParserListener) ExitShow_file_formats(ctx *Show_file_formatsContext) {} + +// EnterShow_functions is called when production show_functions is entered. +func (s *BaseSnowflakeParserListener) EnterShow_functions(ctx *Show_functionsContext) {} + +// ExitShow_functions is called when production show_functions is exited. +func (s *BaseSnowflakeParserListener) ExitShow_functions(ctx *Show_functionsContext) {} + +// EnterShow_global_accounts is called when production show_global_accounts is entered. +func (s *BaseSnowflakeParserListener) EnterShow_global_accounts(ctx *Show_global_accountsContext) {} + +// ExitShow_global_accounts is called when production show_global_accounts is exited. +func (s *BaseSnowflakeParserListener) ExitShow_global_accounts(ctx *Show_global_accountsContext) {} + +// EnterShow_grants is called when production show_grants is entered. +func (s *BaseSnowflakeParserListener) EnterShow_grants(ctx *Show_grantsContext) {} + +// ExitShow_grants is called when production show_grants is exited. +func (s *BaseSnowflakeParserListener) ExitShow_grants(ctx *Show_grantsContext) {} + +// EnterShow_grants_opts is called when production show_grants_opts is entered. +func (s *BaseSnowflakeParserListener) EnterShow_grants_opts(ctx *Show_grants_optsContext) {} + +// ExitShow_grants_opts is called when production show_grants_opts is exited. +func (s *BaseSnowflakeParserListener) ExitShow_grants_opts(ctx *Show_grants_optsContext) {} + +// EnterShow_integrations is called when production show_integrations is entered. +func (s *BaseSnowflakeParserListener) EnterShow_integrations(ctx *Show_integrationsContext) {} + +// ExitShow_integrations is called when production show_integrations is exited. +func (s *BaseSnowflakeParserListener) ExitShow_integrations(ctx *Show_integrationsContext) {} + +// EnterShow_locks is called when production show_locks is entered. +func (s *BaseSnowflakeParserListener) EnterShow_locks(ctx *Show_locksContext) {} + +// ExitShow_locks is called when production show_locks is exited. +func (s *BaseSnowflakeParserListener) ExitShow_locks(ctx *Show_locksContext) {} + +// EnterShow_managed_accounts is called when production show_managed_accounts is entered. +func (s *BaseSnowflakeParserListener) EnterShow_managed_accounts(ctx *Show_managed_accountsContext) {} + +// ExitShow_managed_accounts is called when production show_managed_accounts is exited. +func (s *BaseSnowflakeParserListener) ExitShow_managed_accounts(ctx *Show_managed_accountsContext) {} + +// EnterShow_masking_policies is called when production show_masking_policies is entered. +func (s *BaseSnowflakeParserListener) EnterShow_masking_policies(ctx *Show_masking_policiesContext) {} + +// ExitShow_masking_policies is called when production show_masking_policies is exited. +func (s *BaseSnowflakeParserListener) ExitShow_masking_policies(ctx *Show_masking_policiesContext) {} + +// EnterIn_obj is called when production in_obj is entered. +func (s *BaseSnowflakeParserListener) EnterIn_obj(ctx *In_objContext) {} + +// ExitIn_obj is called when production in_obj is exited. +func (s *BaseSnowflakeParserListener) ExitIn_obj(ctx *In_objContext) {} + +// EnterIn_obj_2 is called when production in_obj_2 is entered. +func (s *BaseSnowflakeParserListener) EnterIn_obj_2(ctx *In_obj_2Context) {} + +// ExitIn_obj_2 is called when production in_obj_2 is exited. +func (s *BaseSnowflakeParserListener) ExitIn_obj_2(ctx *In_obj_2Context) {} + +// EnterShow_materialized_views is called when production show_materialized_views is entered. +func (s *BaseSnowflakeParserListener) EnterShow_materialized_views(ctx *Show_materialized_viewsContext) { +} + +// ExitShow_materialized_views is called when production show_materialized_views is exited. +func (s *BaseSnowflakeParserListener) ExitShow_materialized_views(ctx *Show_materialized_viewsContext) { +} + +// EnterShow_network_policies is called when production show_network_policies is entered. +func (s *BaseSnowflakeParserListener) EnterShow_network_policies(ctx *Show_network_policiesContext) {} + +// ExitShow_network_policies is called when production show_network_policies is exited. +func (s *BaseSnowflakeParserListener) ExitShow_network_policies(ctx *Show_network_policiesContext) {} + +// EnterShow_objects is called when production show_objects is entered. +func (s *BaseSnowflakeParserListener) EnterShow_objects(ctx *Show_objectsContext) {} + +// ExitShow_objects is called when production show_objects is exited. +func (s *BaseSnowflakeParserListener) ExitShow_objects(ctx *Show_objectsContext) {} + +// EnterShow_organization_accounts is called when production show_organization_accounts is entered. +func (s *BaseSnowflakeParserListener) EnterShow_organization_accounts(ctx *Show_organization_accountsContext) { +} + +// ExitShow_organization_accounts is called when production show_organization_accounts is exited. +func (s *BaseSnowflakeParserListener) ExitShow_organization_accounts(ctx *Show_organization_accountsContext) { +} + +// EnterIn_for is called when production in_for is entered. +func (s *BaseSnowflakeParserListener) EnterIn_for(ctx *In_forContext) {} + +// ExitIn_for is called when production in_for is exited. +func (s *BaseSnowflakeParserListener) ExitIn_for(ctx *In_forContext) {} + +// EnterShow_parameters is called when production show_parameters is entered. +func (s *BaseSnowflakeParserListener) EnterShow_parameters(ctx *Show_parametersContext) {} + +// ExitShow_parameters is called when production show_parameters is exited. +func (s *BaseSnowflakeParserListener) ExitShow_parameters(ctx *Show_parametersContext) {} + +// EnterShow_pipes is called when production show_pipes is entered. +func (s *BaseSnowflakeParserListener) EnterShow_pipes(ctx *Show_pipesContext) {} + +// ExitShow_pipes is called when production show_pipes is exited. +func (s *BaseSnowflakeParserListener) ExitShow_pipes(ctx *Show_pipesContext) {} + +// EnterShow_primary_keys is called when production show_primary_keys is entered. +func (s *BaseSnowflakeParserListener) EnterShow_primary_keys(ctx *Show_primary_keysContext) {} + +// ExitShow_primary_keys is called when production show_primary_keys is exited. +func (s *BaseSnowflakeParserListener) ExitShow_primary_keys(ctx *Show_primary_keysContext) {} + +// EnterShow_procedures is called when production show_procedures is entered. +func (s *BaseSnowflakeParserListener) EnterShow_procedures(ctx *Show_proceduresContext) {} + +// ExitShow_procedures is called when production show_procedures is exited. +func (s *BaseSnowflakeParserListener) ExitShow_procedures(ctx *Show_proceduresContext) {} + +// EnterShow_regions is called when production show_regions is entered. +func (s *BaseSnowflakeParserListener) EnterShow_regions(ctx *Show_regionsContext) {} + +// ExitShow_regions is called when production show_regions is exited. +func (s *BaseSnowflakeParserListener) ExitShow_regions(ctx *Show_regionsContext) {} + +// EnterShow_replication_accounts is called when production show_replication_accounts is entered. +func (s *BaseSnowflakeParserListener) EnterShow_replication_accounts(ctx *Show_replication_accountsContext) { +} + +// ExitShow_replication_accounts is called when production show_replication_accounts is exited. +func (s *BaseSnowflakeParserListener) ExitShow_replication_accounts(ctx *Show_replication_accountsContext) { +} + +// EnterShow_replication_databases is called when production show_replication_databases is entered. +func (s *BaseSnowflakeParserListener) EnterShow_replication_databases(ctx *Show_replication_databasesContext) { +} + +// ExitShow_replication_databases is called when production show_replication_databases is exited. +func (s *BaseSnowflakeParserListener) ExitShow_replication_databases(ctx *Show_replication_databasesContext) { +} + +// EnterShow_replication_groups is called when production show_replication_groups is entered. +func (s *BaseSnowflakeParserListener) EnterShow_replication_groups(ctx *Show_replication_groupsContext) { +} + +// ExitShow_replication_groups is called when production show_replication_groups is exited. +func (s *BaseSnowflakeParserListener) ExitShow_replication_groups(ctx *Show_replication_groupsContext) { +} + +// EnterShow_resource_monitors is called when production show_resource_monitors is entered. +func (s *BaseSnowflakeParserListener) EnterShow_resource_monitors(ctx *Show_resource_monitorsContext) { +} + +// ExitShow_resource_monitors is called when production show_resource_monitors is exited. +func (s *BaseSnowflakeParserListener) ExitShow_resource_monitors(ctx *Show_resource_monitorsContext) { +} + +// EnterShow_roles is called when production show_roles is entered. +func (s *BaseSnowflakeParserListener) EnterShow_roles(ctx *Show_rolesContext) {} + +// ExitShow_roles is called when production show_roles is exited. +func (s *BaseSnowflakeParserListener) ExitShow_roles(ctx *Show_rolesContext) {} + +// EnterShow_row_access_policies is called when production show_row_access_policies is entered. +func (s *BaseSnowflakeParserListener) EnterShow_row_access_policies(ctx *Show_row_access_policiesContext) { +} + +// ExitShow_row_access_policies is called when production show_row_access_policies is exited. +func (s *BaseSnowflakeParserListener) ExitShow_row_access_policies(ctx *Show_row_access_policiesContext) { +} + +// EnterShow_schemas is called when production show_schemas is entered. +func (s *BaseSnowflakeParserListener) EnterShow_schemas(ctx *Show_schemasContext) {} + +// ExitShow_schemas is called when production show_schemas is exited. +func (s *BaseSnowflakeParserListener) ExitShow_schemas(ctx *Show_schemasContext) {} + +// EnterShow_sequences is called when production show_sequences is entered. +func (s *BaseSnowflakeParserListener) EnterShow_sequences(ctx *Show_sequencesContext) {} + +// ExitShow_sequences is called when production show_sequences is exited. +func (s *BaseSnowflakeParserListener) ExitShow_sequences(ctx *Show_sequencesContext) {} + +// EnterShow_session_policies is called when production show_session_policies is entered. +func (s *BaseSnowflakeParserListener) EnterShow_session_policies(ctx *Show_session_policiesContext) {} + +// ExitShow_session_policies is called when production show_session_policies is exited. +func (s *BaseSnowflakeParserListener) ExitShow_session_policies(ctx *Show_session_policiesContext) {} + +// EnterShow_shares is called when production show_shares is entered. +func (s *BaseSnowflakeParserListener) EnterShow_shares(ctx *Show_sharesContext) {} + +// ExitShow_shares is called when production show_shares is exited. +func (s *BaseSnowflakeParserListener) ExitShow_shares(ctx *Show_sharesContext) {} + +// EnterShow_shares_in_failover_group is called when production show_shares_in_failover_group is entered. +func (s *BaseSnowflakeParserListener) EnterShow_shares_in_failover_group(ctx *Show_shares_in_failover_groupContext) { +} + +// ExitShow_shares_in_failover_group is called when production show_shares_in_failover_group is exited. +func (s *BaseSnowflakeParserListener) ExitShow_shares_in_failover_group(ctx *Show_shares_in_failover_groupContext) { +} + +// EnterShow_shares_in_replication_group is called when production show_shares_in_replication_group is entered. +func (s *BaseSnowflakeParserListener) EnterShow_shares_in_replication_group(ctx *Show_shares_in_replication_groupContext) { +} + +// ExitShow_shares_in_replication_group is called when production show_shares_in_replication_group is exited. +func (s *BaseSnowflakeParserListener) ExitShow_shares_in_replication_group(ctx *Show_shares_in_replication_groupContext) { +} + +// EnterShow_stages is called when production show_stages is entered. +func (s *BaseSnowflakeParserListener) EnterShow_stages(ctx *Show_stagesContext) {} + +// ExitShow_stages is called when production show_stages is exited. +func (s *BaseSnowflakeParserListener) ExitShow_stages(ctx *Show_stagesContext) {} + +// EnterShow_streams is called when production show_streams is entered. +func (s *BaseSnowflakeParserListener) EnterShow_streams(ctx *Show_streamsContext) {} + +// ExitShow_streams is called when production show_streams is exited. +func (s *BaseSnowflakeParserListener) ExitShow_streams(ctx *Show_streamsContext) {} + +// EnterShow_tables is called when production show_tables is entered. +func (s *BaseSnowflakeParserListener) EnterShow_tables(ctx *Show_tablesContext) {} + +// ExitShow_tables is called when production show_tables is exited. +func (s *BaseSnowflakeParserListener) ExitShow_tables(ctx *Show_tablesContext) {} + +// EnterShow_tags is called when production show_tags is entered. +func (s *BaseSnowflakeParserListener) EnterShow_tags(ctx *Show_tagsContext) {} + +// ExitShow_tags is called when production show_tags is exited. +func (s *BaseSnowflakeParserListener) ExitShow_tags(ctx *Show_tagsContext) {} + +// EnterShow_tasks is called when production show_tasks is entered. +func (s *BaseSnowflakeParserListener) EnterShow_tasks(ctx *Show_tasksContext) {} + +// ExitShow_tasks is called when production show_tasks is exited. +func (s *BaseSnowflakeParserListener) ExitShow_tasks(ctx *Show_tasksContext) {} + +// EnterShow_transactions is called when production show_transactions is entered. +func (s *BaseSnowflakeParserListener) EnterShow_transactions(ctx *Show_transactionsContext) {} + +// ExitShow_transactions is called when production show_transactions is exited. +func (s *BaseSnowflakeParserListener) ExitShow_transactions(ctx *Show_transactionsContext) {} + +// EnterShow_user_functions is called when production show_user_functions is entered. +func (s *BaseSnowflakeParserListener) EnterShow_user_functions(ctx *Show_user_functionsContext) {} + +// ExitShow_user_functions is called when production show_user_functions is exited. +func (s *BaseSnowflakeParserListener) ExitShow_user_functions(ctx *Show_user_functionsContext) {} + +// EnterShow_users is called when production show_users is entered. +func (s *BaseSnowflakeParserListener) EnterShow_users(ctx *Show_usersContext) {} + +// ExitShow_users is called when production show_users is exited. +func (s *BaseSnowflakeParserListener) ExitShow_users(ctx *Show_usersContext) {} + +// EnterShow_variables is called when production show_variables is entered. +func (s *BaseSnowflakeParserListener) EnterShow_variables(ctx *Show_variablesContext) {} + +// ExitShow_variables is called when production show_variables is exited. +func (s *BaseSnowflakeParserListener) ExitShow_variables(ctx *Show_variablesContext) {} + +// EnterShow_views is called when production show_views is entered. +func (s *BaseSnowflakeParserListener) EnterShow_views(ctx *Show_viewsContext) {} + +// ExitShow_views is called when production show_views is exited. +func (s *BaseSnowflakeParserListener) ExitShow_views(ctx *Show_viewsContext) {} + +// EnterShow_warehouses is called when production show_warehouses is entered. +func (s *BaseSnowflakeParserListener) EnterShow_warehouses(ctx *Show_warehousesContext) {} + +// ExitShow_warehouses is called when production show_warehouses is exited. +func (s *BaseSnowflakeParserListener) ExitShow_warehouses(ctx *Show_warehousesContext) {} + +// EnterLike_pattern is called when production like_pattern is entered. +func (s *BaseSnowflakeParserListener) EnterLike_pattern(ctx *Like_patternContext) {} + +// ExitLike_pattern is called when production like_pattern is exited. +func (s *BaseSnowflakeParserListener) ExitLike_pattern(ctx *Like_patternContext) {} + +// EnterAccount_identifier is called when production account_identifier is entered. +func (s *BaseSnowflakeParserListener) EnterAccount_identifier(ctx *Account_identifierContext) {} + +// ExitAccount_identifier is called when production account_identifier is exited. +func (s *BaseSnowflakeParserListener) ExitAccount_identifier(ctx *Account_identifierContext) {} + +// EnterSchema_name is called when production schema_name is entered. +func (s *BaseSnowflakeParserListener) EnterSchema_name(ctx *Schema_nameContext) {} + +// ExitSchema_name is called when production schema_name is exited. +func (s *BaseSnowflakeParserListener) ExitSchema_name(ctx *Schema_nameContext) {} + +// EnterObject_type is called when production object_type is entered. +func (s *BaseSnowflakeParserListener) EnterObject_type(ctx *Object_typeContext) {} + +// ExitObject_type is called when production object_type is exited. +func (s *BaseSnowflakeParserListener) ExitObject_type(ctx *Object_typeContext) {} + +// EnterObject_type_list is called when production object_type_list is entered. +func (s *BaseSnowflakeParserListener) EnterObject_type_list(ctx *Object_type_listContext) {} + +// ExitObject_type_list is called when production object_type_list is exited. +func (s *BaseSnowflakeParserListener) ExitObject_type_list(ctx *Object_type_listContext) {} + +// EnterTag_value is called when production tag_value is entered. +func (s *BaseSnowflakeParserListener) EnterTag_value(ctx *Tag_valueContext) {} + +// ExitTag_value is called when production tag_value is exited. +func (s *BaseSnowflakeParserListener) ExitTag_value(ctx *Tag_valueContext) {} + +// EnterArg_data_type is called when production arg_data_type is entered. +func (s *BaseSnowflakeParserListener) EnterArg_data_type(ctx *Arg_data_typeContext) {} + +// ExitArg_data_type is called when production arg_data_type is exited. +func (s *BaseSnowflakeParserListener) ExitArg_data_type(ctx *Arg_data_typeContext) {} + +// EnterArg_name is called when production arg_name is entered. +func (s *BaseSnowflakeParserListener) EnterArg_name(ctx *Arg_nameContext) {} + +// ExitArg_name is called when production arg_name is exited. +func (s *BaseSnowflakeParserListener) ExitArg_name(ctx *Arg_nameContext) {} + +// EnterParam_name is called when production param_name is entered. +func (s *BaseSnowflakeParserListener) EnterParam_name(ctx *Param_nameContext) {} + +// ExitParam_name is called when production param_name is exited. +func (s *BaseSnowflakeParserListener) ExitParam_name(ctx *Param_nameContext) {} + +// EnterRegion_group_id is called when production region_group_id is entered. +func (s *BaseSnowflakeParserListener) EnterRegion_group_id(ctx *Region_group_idContext) {} + +// ExitRegion_group_id is called when production region_group_id is exited. +func (s *BaseSnowflakeParserListener) ExitRegion_group_id(ctx *Region_group_idContext) {} + +// EnterSnowflake_region_id is called when production snowflake_region_id is entered. +func (s *BaseSnowflakeParserListener) EnterSnowflake_region_id(ctx *Snowflake_region_idContext) {} + +// ExitSnowflake_region_id is called when production snowflake_region_id is exited. +func (s *BaseSnowflakeParserListener) ExitSnowflake_region_id(ctx *Snowflake_region_idContext) {} + +// EnterString is called when production string is entered. +func (s *BaseSnowflakeParserListener) EnterString(ctx *StringContext) {} + +// ExitString is called when production string is exited. +func (s *BaseSnowflakeParserListener) ExitString(ctx *StringContext) {} + +// EnterString_list is called when production string_list is entered. +func (s *BaseSnowflakeParserListener) EnterString_list(ctx *String_listContext) {} + +// ExitString_list is called when production string_list is exited. +func (s *BaseSnowflakeParserListener) ExitString_list(ctx *String_listContext) {} + +// EnterId_ is called when production id_ is entered. +func (s *BaseSnowflakeParserListener) EnterId_(ctx *Id_Context) {} + +// ExitId_ is called when production id_ is exited. +func (s *BaseSnowflakeParserListener) ExitId_(ctx *Id_Context) {} + +// EnterKeyword is called when production keyword is entered. +func (s *BaseSnowflakeParserListener) EnterKeyword(ctx *KeywordContext) {} + +// ExitKeyword is called when production keyword is exited. +func (s *BaseSnowflakeParserListener) ExitKeyword(ctx *KeywordContext) {} + +// EnterNon_reserved_words is called when production non_reserved_words is entered. +func (s *BaseSnowflakeParserListener) EnterNon_reserved_words(ctx *Non_reserved_wordsContext) {} + +// ExitNon_reserved_words is called when production non_reserved_words is exited. +func (s *BaseSnowflakeParserListener) ExitNon_reserved_words(ctx *Non_reserved_wordsContext) {} + +// EnterBuiltin_function is called when production builtin_function is entered. +func (s *BaseSnowflakeParserListener) EnterBuiltin_function(ctx *Builtin_functionContext) {} + +// ExitBuiltin_function is called when production builtin_function is exited. +func (s *BaseSnowflakeParserListener) ExitBuiltin_function(ctx *Builtin_functionContext) {} + +// EnterList_operator is called when production list_operator is entered. +func (s *BaseSnowflakeParserListener) EnterList_operator(ctx *List_operatorContext) {} + +// ExitList_operator is called when production list_operator is exited. +func (s *BaseSnowflakeParserListener) ExitList_operator(ctx *List_operatorContext) {} + +// EnterBinary_builtin_function is called when production binary_builtin_function is entered. +func (s *BaseSnowflakeParserListener) EnterBinary_builtin_function(ctx *Binary_builtin_functionContext) { +} + +// ExitBinary_builtin_function is called when production binary_builtin_function is exited. +func (s *BaseSnowflakeParserListener) ExitBinary_builtin_function(ctx *Binary_builtin_functionContext) { +} + +// EnterBinary_or_ternary_builtin_function is called when production binary_or_ternary_builtin_function is entered. +func (s *BaseSnowflakeParserListener) EnterBinary_or_ternary_builtin_function(ctx *Binary_or_ternary_builtin_functionContext) { +} + +// ExitBinary_or_ternary_builtin_function is called when production binary_or_ternary_builtin_function is exited. +func (s *BaseSnowflakeParserListener) ExitBinary_or_ternary_builtin_function(ctx *Binary_or_ternary_builtin_functionContext) { +} + +// EnterTernary_builtin_function is called when production ternary_builtin_function is entered. +func (s *BaseSnowflakeParserListener) EnterTernary_builtin_function(ctx *Ternary_builtin_functionContext) { +} + +// ExitTernary_builtin_function is called when production ternary_builtin_function is exited. +func (s *BaseSnowflakeParserListener) ExitTernary_builtin_function(ctx *Ternary_builtin_functionContext) { +} + +// EnterPattern is called when production pattern is entered. +func (s *BaseSnowflakeParserListener) EnterPattern(ctx *PatternContext) {} + +// ExitPattern is called when production pattern is exited. +func (s *BaseSnowflakeParserListener) ExitPattern(ctx *PatternContext) {} + +// EnterColumn_name is called when production column_name is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_name(ctx *Column_nameContext) {} + +// ExitColumn_name is called when production column_name is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_name(ctx *Column_nameContext) {} + +// EnterColumn_list is called when production column_list is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_list(ctx *Column_listContext) {} + +// ExitColumn_list is called when production column_list is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_list(ctx *Column_listContext) {} + +// EnterObject_name is called when production object_name is entered. +func (s *BaseSnowflakeParserListener) EnterObject_name(ctx *Object_nameContext) {} + +// ExitObject_name is called when production object_name is exited. +func (s *BaseSnowflakeParserListener) ExitObject_name(ctx *Object_nameContext) {} + +// EnterNum is called when production num is entered. +func (s *BaseSnowflakeParserListener) EnterNum(ctx *NumContext) {} + +// ExitNum is called when production num is exited. +func (s *BaseSnowflakeParserListener) ExitNum(ctx *NumContext) {} + +// EnterExpr_list is called when production expr_list is entered. +func (s *BaseSnowflakeParserListener) EnterExpr_list(ctx *Expr_listContext) {} + +// ExitExpr_list is called when production expr_list is exited. +func (s *BaseSnowflakeParserListener) ExitExpr_list(ctx *Expr_listContext) {} + +// EnterExpr_list_sorted is called when production expr_list_sorted is entered. +func (s *BaseSnowflakeParserListener) EnterExpr_list_sorted(ctx *Expr_list_sortedContext) {} + +// ExitExpr_list_sorted is called when production expr_list_sorted is exited. +func (s *BaseSnowflakeParserListener) ExitExpr_list_sorted(ctx *Expr_list_sortedContext) {} + +// EnterExpr is called when production expr is entered. +func (s *BaseSnowflakeParserListener) EnterExpr(ctx *ExprContext) {} + +// ExitExpr is called when production expr is exited. +func (s *BaseSnowflakeParserListener) ExitExpr(ctx *ExprContext) {} + +// EnterIff_expr is called when production iff_expr is entered. +func (s *BaseSnowflakeParserListener) EnterIff_expr(ctx *Iff_exprContext) {} + +// ExitIff_expr is called when production iff_expr is exited. +func (s *BaseSnowflakeParserListener) ExitIff_expr(ctx *Iff_exprContext) {} + +// EnterTrim_expression is called when production trim_expression is entered. +func (s *BaseSnowflakeParserListener) EnterTrim_expression(ctx *Trim_expressionContext) {} + +// ExitTrim_expression is called when production trim_expression is exited. +func (s *BaseSnowflakeParserListener) ExitTrim_expression(ctx *Trim_expressionContext) {} + +// EnterTry_cast_expr is called when production try_cast_expr is entered. +func (s *BaseSnowflakeParserListener) EnterTry_cast_expr(ctx *Try_cast_exprContext) {} + +// ExitTry_cast_expr is called when production try_cast_expr is exited. +func (s *BaseSnowflakeParserListener) ExitTry_cast_expr(ctx *Try_cast_exprContext) {} + +// EnterJson_literal is called when production json_literal is entered. +func (s *BaseSnowflakeParserListener) EnterJson_literal(ctx *Json_literalContext) {} + +// ExitJson_literal is called when production json_literal is exited. +func (s *BaseSnowflakeParserListener) ExitJson_literal(ctx *Json_literalContext) {} + +// EnterKv_pair is called when production kv_pair is entered. +func (s *BaseSnowflakeParserListener) EnterKv_pair(ctx *Kv_pairContext) {} + +// ExitKv_pair is called when production kv_pair is exited. +func (s *BaseSnowflakeParserListener) ExitKv_pair(ctx *Kv_pairContext) {} + +// EnterValue is called when production value is entered. +func (s *BaseSnowflakeParserListener) EnterValue(ctx *ValueContext) {} + +// ExitValue is called when production value is exited. +func (s *BaseSnowflakeParserListener) ExitValue(ctx *ValueContext) {} + +// EnterArr_literal is called when production arr_literal is entered. +func (s *BaseSnowflakeParserListener) EnterArr_literal(ctx *Arr_literalContext) {} + +// ExitArr_literal is called when production arr_literal is exited. +func (s *BaseSnowflakeParserListener) ExitArr_literal(ctx *Arr_literalContext) {} + +// EnterData_type is called when production data_type is entered. +func (s *BaseSnowflakeParserListener) EnterData_type(ctx *Data_typeContext) {} + +// ExitData_type is called when production data_type is exited. +func (s *BaseSnowflakeParserListener) ExitData_type(ctx *Data_typeContext) {} + +// EnterPrimitive_expression is called when production primitive_expression is entered. +func (s *BaseSnowflakeParserListener) EnterPrimitive_expression(ctx *Primitive_expressionContext) {} + +// ExitPrimitive_expression is called when production primitive_expression is exited. +func (s *BaseSnowflakeParserListener) ExitPrimitive_expression(ctx *Primitive_expressionContext) {} + +// EnterOrder_by_expr is called when production order_by_expr is entered. +func (s *BaseSnowflakeParserListener) EnterOrder_by_expr(ctx *Order_by_exprContext) {} + +// ExitOrder_by_expr is called when production order_by_expr is exited. +func (s *BaseSnowflakeParserListener) ExitOrder_by_expr(ctx *Order_by_exprContext) {} + +// EnterAsc_desc is called when production asc_desc is entered. +func (s *BaseSnowflakeParserListener) EnterAsc_desc(ctx *Asc_descContext) {} + +// ExitAsc_desc is called when production asc_desc is exited. +func (s *BaseSnowflakeParserListener) ExitAsc_desc(ctx *Asc_descContext) {} + +// EnterOver_clause is called when production over_clause is entered. +func (s *BaseSnowflakeParserListener) EnterOver_clause(ctx *Over_clauseContext) {} + +// ExitOver_clause is called when production over_clause is exited. +func (s *BaseSnowflakeParserListener) ExitOver_clause(ctx *Over_clauseContext) {} + +// EnterFunction_call is called when production function_call is entered. +func (s *BaseSnowflakeParserListener) EnterFunction_call(ctx *Function_callContext) {} + +// ExitFunction_call is called when production function_call is exited. +func (s *BaseSnowflakeParserListener) ExitFunction_call(ctx *Function_callContext) {} + +// EnterRanking_windowed_function is called when production ranking_windowed_function is entered. +func (s *BaseSnowflakeParserListener) EnterRanking_windowed_function(ctx *Ranking_windowed_functionContext) { +} + +// ExitRanking_windowed_function is called when production ranking_windowed_function is exited. +func (s *BaseSnowflakeParserListener) ExitRanking_windowed_function(ctx *Ranking_windowed_functionContext) { +} + +// EnterAggregate_function is called when production aggregate_function is entered. +func (s *BaseSnowflakeParserListener) EnterAggregate_function(ctx *Aggregate_functionContext) {} + +// ExitAggregate_function is called when production aggregate_function is exited. +func (s *BaseSnowflakeParserListener) ExitAggregate_function(ctx *Aggregate_functionContext) {} + +// EnterLiteral is called when production literal is entered. +func (s *BaseSnowflakeParserListener) EnterLiteral(ctx *LiteralContext) {} + +// ExitLiteral is called when production literal is exited. +func (s *BaseSnowflakeParserListener) ExitLiteral(ctx *LiteralContext) {} + +// EnterSign is called when production sign is entered. +func (s *BaseSnowflakeParserListener) EnterSign(ctx *SignContext) {} + +// ExitSign is called when production sign is exited. +func (s *BaseSnowflakeParserListener) ExitSign(ctx *SignContext) {} + +// EnterFull_column_name is called when production full_column_name is entered. +func (s *BaseSnowflakeParserListener) EnterFull_column_name(ctx *Full_column_nameContext) {} + +// ExitFull_column_name is called when production full_column_name is exited. +func (s *BaseSnowflakeParserListener) ExitFull_column_name(ctx *Full_column_nameContext) {} + +// EnterBracket_expression is called when production bracket_expression is entered. +func (s *BaseSnowflakeParserListener) EnterBracket_expression(ctx *Bracket_expressionContext) {} + +// ExitBracket_expression is called when production bracket_expression is exited. +func (s *BaseSnowflakeParserListener) ExitBracket_expression(ctx *Bracket_expressionContext) {} + +// EnterCase_expression is called when production case_expression is entered. +func (s *BaseSnowflakeParserListener) EnterCase_expression(ctx *Case_expressionContext) {} + +// ExitCase_expression is called when production case_expression is exited. +func (s *BaseSnowflakeParserListener) ExitCase_expression(ctx *Case_expressionContext) {} + +// EnterSwitch_search_condition_section is called when production switch_search_condition_section is entered. +func (s *BaseSnowflakeParserListener) EnterSwitch_search_condition_section(ctx *Switch_search_condition_sectionContext) { +} + +// ExitSwitch_search_condition_section is called when production switch_search_condition_section is exited. +func (s *BaseSnowflakeParserListener) ExitSwitch_search_condition_section(ctx *Switch_search_condition_sectionContext) { +} + +// EnterSwitch_section is called when production switch_section is entered. +func (s *BaseSnowflakeParserListener) EnterSwitch_section(ctx *Switch_sectionContext) {} + +// ExitSwitch_section is called when production switch_section is exited. +func (s *BaseSnowflakeParserListener) ExitSwitch_section(ctx *Switch_sectionContext) {} + +// EnterQuery_statement is called when production query_statement is entered. +func (s *BaseSnowflakeParserListener) EnterQuery_statement(ctx *Query_statementContext) {} + +// ExitQuery_statement is called when production query_statement is exited. +func (s *BaseSnowflakeParserListener) ExitQuery_statement(ctx *Query_statementContext) {} + +// EnterWith_expression is called when production with_expression is entered. +func (s *BaseSnowflakeParserListener) EnterWith_expression(ctx *With_expressionContext) {} + +// ExitWith_expression is called when production with_expression is exited. +func (s *BaseSnowflakeParserListener) ExitWith_expression(ctx *With_expressionContext) {} + +// EnterCommon_table_expression is called when production common_table_expression is entered. +func (s *BaseSnowflakeParserListener) EnterCommon_table_expression(ctx *Common_table_expressionContext) { +} + +// ExitCommon_table_expression is called when production common_table_expression is exited. +func (s *BaseSnowflakeParserListener) ExitCommon_table_expression(ctx *Common_table_expressionContext) { +} + +// EnterAnchor_clause is called when production anchor_clause is entered. +func (s *BaseSnowflakeParserListener) EnterAnchor_clause(ctx *Anchor_clauseContext) {} + +// ExitAnchor_clause is called when production anchor_clause is exited. +func (s *BaseSnowflakeParserListener) ExitAnchor_clause(ctx *Anchor_clauseContext) {} + +// EnterRecursive_clause is called when production recursive_clause is entered. +func (s *BaseSnowflakeParserListener) EnterRecursive_clause(ctx *Recursive_clauseContext) {} + +// ExitRecursive_clause is called when production recursive_clause is exited. +func (s *BaseSnowflakeParserListener) ExitRecursive_clause(ctx *Recursive_clauseContext) {} + +// EnterSelect_statement is called when production select_statement is entered. +func (s *BaseSnowflakeParserListener) EnterSelect_statement(ctx *Select_statementContext) {} + +// ExitSelect_statement is called when production select_statement is exited. +func (s *BaseSnowflakeParserListener) ExitSelect_statement(ctx *Select_statementContext) {} + +// EnterSet_operators is called when production set_operators is entered. +func (s *BaseSnowflakeParserListener) EnterSet_operators(ctx *Set_operatorsContext) {} + +// ExitSet_operators is called when production set_operators is exited. +func (s *BaseSnowflakeParserListener) ExitSet_operators(ctx *Set_operatorsContext) {} + +// EnterSelect_optional_clauses is called when production select_optional_clauses is entered. +func (s *BaseSnowflakeParserListener) EnterSelect_optional_clauses(ctx *Select_optional_clausesContext) { +} + +// ExitSelect_optional_clauses is called when production select_optional_clauses is exited. +func (s *BaseSnowflakeParserListener) ExitSelect_optional_clauses(ctx *Select_optional_clausesContext) { +} + +// EnterSelect_clause is called when production select_clause is entered. +func (s *BaseSnowflakeParserListener) EnterSelect_clause(ctx *Select_clauseContext) {} + +// ExitSelect_clause is called when production select_clause is exited. +func (s *BaseSnowflakeParserListener) ExitSelect_clause(ctx *Select_clauseContext) {} + +// EnterSelect_top_clause is called when production select_top_clause is entered. +func (s *BaseSnowflakeParserListener) EnterSelect_top_clause(ctx *Select_top_clauseContext) {} + +// ExitSelect_top_clause is called when production select_top_clause is exited. +func (s *BaseSnowflakeParserListener) ExitSelect_top_clause(ctx *Select_top_clauseContext) {} + +// EnterSelect_list_no_top is called when production select_list_no_top is entered. +func (s *BaseSnowflakeParserListener) EnterSelect_list_no_top(ctx *Select_list_no_topContext) {} + +// ExitSelect_list_no_top is called when production select_list_no_top is exited. +func (s *BaseSnowflakeParserListener) ExitSelect_list_no_top(ctx *Select_list_no_topContext) {} + +// EnterSelect_list_top is called when production select_list_top is entered. +func (s *BaseSnowflakeParserListener) EnterSelect_list_top(ctx *Select_list_topContext) {} + +// ExitSelect_list_top is called when production select_list_top is exited. +func (s *BaseSnowflakeParserListener) ExitSelect_list_top(ctx *Select_list_topContext) {} + +// EnterSelect_list is called when production select_list is entered. +func (s *BaseSnowflakeParserListener) EnterSelect_list(ctx *Select_listContext) {} + +// ExitSelect_list is called when production select_list is exited. +func (s *BaseSnowflakeParserListener) ExitSelect_list(ctx *Select_listContext) {} + +// EnterSelect_list_elem is called when production select_list_elem is entered. +func (s *BaseSnowflakeParserListener) EnterSelect_list_elem(ctx *Select_list_elemContext) {} + +// ExitSelect_list_elem is called when production select_list_elem is exited. +func (s *BaseSnowflakeParserListener) ExitSelect_list_elem(ctx *Select_list_elemContext) {} + +// EnterColumn_elem is called when production column_elem is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_elem(ctx *Column_elemContext) {} + +// ExitColumn_elem is called when production column_elem is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_elem(ctx *Column_elemContext) {} + +// EnterAs_alias is called when production as_alias is entered. +func (s *BaseSnowflakeParserListener) EnterAs_alias(ctx *As_aliasContext) {} + +// ExitAs_alias is called when production as_alias is exited. +func (s *BaseSnowflakeParserListener) ExitAs_alias(ctx *As_aliasContext) {} + +// EnterExpression_elem is called when production expression_elem is entered. +func (s *BaseSnowflakeParserListener) EnterExpression_elem(ctx *Expression_elemContext) {} + +// ExitExpression_elem is called when production expression_elem is exited. +func (s *BaseSnowflakeParserListener) ExitExpression_elem(ctx *Expression_elemContext) {} + +// EnterColumn_position is called when production column_position is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_position(ctx *Column_positionContext) {} + +// ExitColumn_position is called when production column_position is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_position(ctx *Column_positionContext) {} + +// EnterAll_distinct is called when production all_distinct is entered. +func (s *BaseSnowflakeParserListener) EnterAll_distinct(ctx *All_distinctContext) {} + +// ExitAll_distinct is called when production all_distinct is exited. +func (s *BaseSnowflakeParserListener) ExitAll_distinct(ctx *All_distinctContext) {} + +// EnterTop_clause is called when production top_clause is entered. +func (s *BaseSnowflakeParserListener) EnterTop_clause(ctx *Top_clauseContext) {} + +// ExitTop_clause is called when production top_clause is exited. +func (s *BaseSnowflakeParserListener) ExitTop_clause(ctx *Top_clauseContext) {} + +// EnterInto_clause is called when production into_clause is entered. +func (s *BaseSnowflakeParserListener) EnterInto_clause(ctx *Into_clauseContext) {} + +// ExitInto_clause is called when production into_clause is exited. +func (s *BaseSnowflakeParserListener) ExitInto_clause(ctx *Into_clauseContext) {} + +// EnterVar_list is called when production var_list is entered. +func (s *BaseSnowflakeParserListener) EnterVar_list(ctx *Var_listContext) {} + +// ExitVar_list is called when production var_list is exited. +func (s *BaseSnowflakeParserListener) ExitVar_list(ctx *Var_listContext) {} + +// EnterVar is called when production var is entered. +func (s *BaseSnowflakeParserListener) EnterVar(ctx *VarContext) {} + +// ExitVar is called when production var is exited. +func (s *BaseSnowflakeParserListener) ExitVar(ctx *VarContext) {} + +// EnterFrom_clause is called when production from_clause is entered. +func (s *BaseSnowflakeParserListener) EnterFrom_clause(ctx *From_clauseContext) {} + +// ExitFrom_clause is called when production from_clause is exited. +func (s *BaseSnowflakeParserListener) ExitFrom_clause(ctx *From_clauseContext) {} + +// EnterTable_sources is called when production table_sources is entered. +func (s *BaseSnowflakeParserListener) EnterTable_sources(ctx *Table_sourcesContext) {} + +// ExitTable_sources is called when production table_sources is exited. +func (s *BaseSnowflakeParserListener) ExitTable_sources(ctx *Table_sourcesContext) {} + +// EnterTable_source is called when production table_source is entered. +func (s *BaseSnowflakeParserListener) EnterTable_source(ctx *Table_sourceContext) {} + +// ExitTable_source is called when production table_source is exited. +func (s *BaseSnowflakeParserListener) ExitTable_source(ctx *Table_sourceContext) {} + +// EnterTable_source_item_joined is called when production table_source_item_joined is entered. +func (s *BaseSnowflakeParserListener) EnterTable_source_item_joined(ctx *Table_source_item_joinedContext) { +} + +// ExitTable_source_item_joined is called when production table_source_item_joined is exited. +func (s *BaseSnowflakeParserListener) ExitTable_source_item_joined(ctx *Table_source_item_joinedContext) { +} + +// EnterObject_ref is called when production object_ref is entered. +func (s *BaseSnowflakeParserListener) EnterObject_ref(ctx *Object_refContext) {} + +// ExitObject_ref is called when production object_ref is exited. +func (s *BaseSnowflakeParserListener) ExitObject_ref(ctx *Object_refContext) {} + +// EnterFlatten_table_option is called when production flatten_table_option is entered. +func (s *BaseSnowflakeParserListener) EnterFlatten_table_option(ctx *Flatten_table_optionContext) {} + +// ExitFlatten_table_option is called when production flatten_table_option is exited. +func (s *BaseSnowflakeParserListener) ExitFlatten_table_option(ctx *Flatten_table_optionContext) {} + +// EnterFlatten_table is called when production flatten_table is entered. +func (s *BaseSnowflakeParserListener) EnterFlatten_table(ctx *Flatten_tableContext) {} + +// ExitFlatten_table is called when production flatten_table is exited. +func (s *BaseSnowflakeParserListener) ExitFlatten_table(ctx *Flatten_tableContext) {} + +// EnterPrior_list is called when production prior_list is entered. +func (s *BaseSnowflakeParserListener) EnterPrior_list(ctx *Prior_listContext) {} + +// ExitPrior_list is called when production prior_list is exited. +func (s *BaseSnowflakeParserListener) ExitPrior_list(ctx *Prior_listContext) {} + +// EnterPrior_item is called when production prior_item is entered. +func (s *BaseSnowflakeParserListener) EnterPrior_item(ctx *Prior_itemContext) {} + +// ExitPrior_item is called when production prior_item is exited. +func (s *BaseSnowflakeParserListener) ExitPrior_item(ctx *Prior_itemContext) {} + +// EnterOuter_join is called when production outer_join is entered. +func (s *BaseSnowflakeParserListener) EnterOuter_join(ctx *Outer_joinContext) {} + +// ExitOuter_join is called when production outer_join is exited. +func (s *BaseSnowflakeParserListener) ExitOuter_join(ctx *Outer_joinContext) {} + +// EnterJoin_type is called when production join_type is entered. +func (s *BaseSnowflakeParserListener) EnterJoin_type(ctx *Join_typeContext) {} + +// ExitJoin_type is called when production join_type is exited. +func (s *BaseSnowflakeParserListener) ExitJoin_type(ctx *Join_typeContext) {} + +// EnterJoin_clause is called when production join_clause is entered. +func (s *BaseSnowflakeParserListener) EnterJoin_clause(ctx *Join_clauseContext) {} + +// ExitJoin_clause is called when production join_clause is exited. +func (s *BaseSnowflakeParserListener) ExitJoin_clause(ctx *Join_clauseContext) {} + +// EnterAt_before is called when production at_before is entered. +func (s *BaseSnowflakeParserListener) EnterAt_before(ctx *At_beforeContext) {} + +// ExitAt_before is called when production at_before is exited. +func (s *BaseSnowflakeParserListener) ExitAt_before(ctx *At_beforeContext) {} + +// EnterEnd is called when production end is entered. +func (s *BaseSnowflakeParserListener) EnterEnd(ctx *EndContext) {} + +// ExitEnd is called when production end is exited. +func (s *BaseSnowflakeParserListener) ExitEnd(ctx *EndContext) {} + +// EnterChanges is called when production changes is entered. +func (s *BaseSnowflakeParserListener) EnterChanges(ctx *ChangesContext) {} + +// ExitChanges is called when production changes is exited. +func (s *BaseSnowflakeParserListener) ExitChanges(ctx *ChangesContext) {} + +// EnterDefault_append_only is called when production default_append_only is entered. +func (s *BaseSnowflakeParserListener) EnterDefault_append_only(ctx *Default_append_onlyContext) {} + +// ExitDefault_append_only is called when production default_append_only is exited. +func (s *BaseSnowflakeParserListener) ExitDefault_append_only(ctx *Default_append_onlyContext) {} + +// EnterPartition_by is called when production partition_by is entered. +func (s *BaseSnowflakeParserListener) EnterPartition_by(ctx *Partition_byContext) {} + +// ExitPartition_by is called when production partition_by is exited. +func (s *BaseSnowflakeParserListener) ExitPartition_by(ctx *Partition_byContext) {} + +// EnterAlias is called when production alias is entered. +func (s *BaseSnowflakeParserListener) EnterAlias(ctx *AliasContext) {} + +// ExitAlias is called when production alias is exited. +func (s *BaseSnowflakeParserListener) ExitAlias(ctx *AliasContext) {} + +// EnterExpr_alias_list is called when production expr_alias_list is entered. +func (s *BaseSnowflakeParserListener) EnterExpr_alias_list(ctx *Expr_alias_listContext) {} + +// ExitExpr_alias_list is called when production expr_alias_list is exited. +func (s *BaseSnowflakeParserListener) ExitExpr_alias_list(ctx *Expr_alias_listContext) {} + +// EnterMeasures is called when production measures is entered. +func (s *BaseSnowflakeParserListener) EnterMeasures(ctx *MeasuresContext) {} + +// ExitMeasures is called when production measures is exited. +func (s *BaseSnowflakeParserListener) ExitMeasures(ctx *MeasuresContext) {} + +// EnterMatch_opts is called when production match_opts is entered. +func (s *BaseSnowflakeParserListener) EnterMatch_opts(ctx *Match_optsContext) {} + +// ExitMatch_opts is called when production match_opts is exited. +func (s *BaseSnowflakeParserListener) ExitMatch_opts(ctx *Match_optsContext) {} + +// EnterRow_match is called when production row_match is entered. +func (s *BaseSnowflakeParserListener) EnterRow_match(ctx *Row_matchContext) {} + +// ExitRow_match is called when production row_match is exited. +func (s *BaseSnowflakeParserListener) ExitRow_match(ctx *Row_matchContext) {} + +// EnterFirst_last is called when production first_last is entered. +func (s *BaseSnowflakeParserListener) EnterFirst_last(ctx *First_lastContext) {} + +// ExitFirst_last is called when production first_last is exited. +func (s *BaseSnowflakeParserListener) ExitFirst_last(ctx *First_lastContext) {} + +// EnterSymbol is called when production symbol is entered. +func (s *BaseSnowflakeParserListener) EnterSymbol(ctx *SymbolContext) {} + +// ExitSymbol is called when production symbol is exited. +func (s *BaseSnowflakeParserListener) ExitSymbol(ctx *SymbolContext) {} + +// EnterAfter_match is called when production after_match is entered. +func (s *BaseSnowflakeParserListener) EnterAfter_match(ctx *After_matchContext) {} + +// ExitAfter_match is called when production after_match is exited. +func (s *BaseSnowflakeParserListener) ExitAfter_match(ctx *After_matchContext) {} + +// EnterSymbol_list is called when production symbol_list is entered. +func (s *BaseSnowflakeParserListener) EnterSymbol_list(ctx *Symbol_listContext) {} + +// ExitSymbol_list is called when production symbol_list is exited. +func (s *BaseSnowflakeParserListener) ExitSymbol_list(ctx *Symbol_listContext) {} + +// EnterDefine is called when production define is entered. +func (s *BaseSnowflakeParserListener) EnterDefine(ctx *DefineContext) {} + +// ExitDefine is called when production define is exited. +func (s *BaseSnowflakeParserListener) ExitDefine(ctx *DefineContext) {} + +// EnterMatch_recognize is called when production match_recognize is entered. +func (s *BaseSnowflakeParserListener) EnterMatch_recognize(ctx *Match_recognizeContext) {} + +// ExitMatch_recognize is called when production match_recognize is exited. +func (s *BaseSnowflakeParserListener) ExitMatch_recognize(ctx *Match_recognizeContext) {} + +// EnterPivot_unpivot is called when production pivot_unpivot is entered. +func (s *BaseSnowflakeParserListener) EnterPivot_unpivot(ctx *Pivot_unpivotContext) {} + +// ExitPivot_unpivot is called when production pivot_unpivot is exited. +func (s *BaseSnowflakeParserListener) ExitPivot_unpivot(ctx *Pivot_unpivotContext) {} + +// EnterColumn_alias_list_in_brackets is called when production column_alias_list_in_brackets is entered. +func (s *BaseSnowflakeParserListener) EnterColumn_alias_list_in_brackets(ctx *Column_alias_list_in_bracketsContext) { +} + +// ExitColumn_alias_list_in_brackets is called when production column_alias_list_in_brackets is exited. +func (s *BaseSnowflakeParserListener) ExitColumn_alias_list_in_brackets(ctx *Column_alias_list_in_bracketsContext) { +} + +// EnterExpr_list_in_parentheses is called when production expr_list_in_parentheses is entered. +func (s *BaseSnowflakeParserListener) EnterExpr_list_in_parentheses(ctx *Expr_list_in_parenthesesContext) { +} + +// ExitExpr_list_in_parentheses is called when production expr_list_in_parentheses is exited. +func (s *BaseSnowflakeParserListener) ExitExpr_list_in_parentheses(ctx *Expr_list_in_parenthesesContext) { +} + +// EnterValues is called when production values is entered. +func (s *BaseSnowflakeParserListener) EnterValues(ctx *ValuesContext) {} + +// ExitValues is called when production values is exited. +func (s *BaseSnowflakeParserListener) ExitValues(ctx *ValuesContext) {} + +// EnterSample_method is called when production sample_method is entered. +func (s *BaseSnowflakeParserListener) EnterSample_method(ctx *Sample_methodContext) {} + +// ExitSample_method is called when production sample_method is exited. +func (s *BaseSnowflakeParserListener) ExitSample_method(ctx *Sample_methodContext) {} + +// EnterRepeatable_seed is called when production repeatable_seed is entered. +func (s *BaseSnowflakeParserListener) EnterRepeatable_seed(ctx *Repeatable_seedContext) {} + +// ExitRepeatable_seed is called when production repeatable_seed is exited. +func (s *BaseSnowflakeParserListener) ExitRepeatable_seed(ctx *Repeatable_seedContext) {} + +// EnterSample_opts is called when production sample_opts is entered. +func (s *BaseSnowflakeParserListener) EnterSample_opts(ctx *Sample_optsContext) {} + +// ExitSample_opts is called when production sample_opts is exited. +func (s *BaseSnowflakeParserListener) ExitSample_opts(ctx *Sample_optsContext) {} + +// EnterSample is called when production sample is entered. +func (s *BaseSnowflakeParserListener) EnterSample(ctx *SampleContext) {} + +// ExitSample is called when production sample is exited. +func (s *BaseSnowflakeParserListener) ExitSample(ctx *SampleContext) {} + +// EnterSearch_condition is called when production search_condition is entered. +func (s *BaseSnowflakeParserListener) EnterSearch_condition(ctx *Search_conditionContext) {} + +// ExitSearch_condition is called when production search_condition is exited. +func (s *BaseSnowflakeParserListener) ExitSearch_condition(ctx *Search_conditionContext) {} + +// EnterComparison_operator is called when production comparison_operator is entered. +func (s *BaseSnowflakeParserListener) EnterComparison_operator(ctx *Comparison_operatorContext) {} + +// ExitComparison_operator is called when production comparison_operator is exited. +func (s *BaseSnowflakeParserListener) ExitComparison_operator(ctx *Comparison_operatorContext) {} + +// EnterNull_not_null is called when production null_not_null is entered. +func (s *BaseSnowflakeParserListener) EnterNull_not_null(ctx *Null_not_nullContext) {} + +// ExitNull_not_null is called when production null_not_null is exited. +func (s *BaseSnowflakeParserListener) ExitNull_not_null(ctx *Null_not_nullContext) {} + +// EnterSubquery is called when production subquery is entered. +func (s *BaseSnowflakeParserListener) EnterSubquery(ctx *SubqueryContext) {} + +// ExitSubquery is called when production subquery is exited. +func (s *BaseSnowflakeParserListener) ExitSubquery(ctx *SubqueryContext) {} + +// EnterPredicate is called when production predicate is entered. +func (s *BaseSnowflakeParserListener) EnterPredicate(ctx *PredicateContext) {} + +// ExitPredicate is called when production predicate is exited. +func (s *BaseSnowflakeParserListener) ExitPredicate(ctx *PredicateContext) {} + +// EnterWhere_clause is called when production where_clause is entered. +func (s *BaseSnowflakeParserListener) EnterWhere_clause(ctx *Where_clauseContext) {} + +// ExitWhere_clause is called when production where_clause is exited. +func (s *BaseSnowflakeParserListener) ExitWhere_clause(ctx *Where_clauseContext) {} + +// EnterGroup_item is called when production group_item is entered. +func (s *BaseSnowflakeParserListener) EnterGroup_item(ctx *Group_itemContext) {} + +// ExitGroup_item is called when production group_item is exited. +func (s *BaseSnowflakeParserListener) ExitGroup_item(ctx *Group_itemContext) {} + +// EnterGroup_by_clause is called when production group_by_clause is entered. +func (s *BaseSnowflakeParserListener) EnterGroup_by_clause(ctx *Group_by_clauseContext) {} + +// ExitGroup_by_clause is called when production group_by_clause is exited. +func (s *BaseSnowflakeParserListener) ExitGroup_by_clause(ctx *Group_by_clauseContext) {} + +// EnterHaving_clause is called when production having_clause is entered. +func (s *BaseSnowflakeParserListener) EnterHaving_clause(ctx *Having_clauseContext) {} + +// ExitHaving_clause is called when production having_clause is exited. +func (s *BaseSnowflakeParserListener) ExitHaving_clause(ctx *Having_clauseContext) {} + +// EnterQualify_clause is called when production qualify_clause is entered. +func (s *BaseSnowflakeParserListener) EnterQualify_clause(ctx *Qualify_clauseContext) {} + +// ExitQualify_clause is called when production qualify_clause is exited. +func (s *BaseSnowflakeParserListener) ExitQualify_clause(ctx *Qualify_clauseContext) {} + +// EnterOrder_item is called when production order_item is entered. +func (s *BaseSnowflakeParserListener) EnterOrder_item(ctx *Order_itemContext) {} + +// ExitOrder_item is called when production order_item is exited. +func (s *BaseSnowflakeParserListener) ExitOrder_item(ctx *Order_itemContext) {} + +// EnterOrder_by_clause is called when production order_by_clause is entered. +func (s *BaseSnowflakeParserListener) EnterOrder_by_clause(ctx *Order_by_clauseContext) {} + +// ExitOrder_by_clause is called when production order_by_clause is exited. +func (s *BaseSnowflakeParserListener) ExitOrder_by_clause(ctx *Order_by_clauseContext) {} + +// EnterRow_rows is called when production row_rows is entered. +func (s *BaseSnowflakeParserListener) EnterRow_rows(ctx *Row_rowsContext) {} + +// ExitRow_rows is called when production row_rows is exited. +func (s *BaseSnowflakeParserListener) ExitRow_rows(ctx *Row_rowsContext) {} + +// EnterFirst_next is called when production first_next is entered. +func (s *BaseSnowflakeParserListener) EnterFirst_next(ctx *First_nextContext) {} + +// ExitFirst_next is called when production first_next is exited. +func (s *BaseSnowflakeParserListener) ExitFirst_next(ctx *First_nextContext) {} + +// EnterLimit_clause is called when production limit_clause is entered. +func (s *BaseSnowflakeParserListener) EnterLimit_clause(ctx *Limit_clauseContext) {} + +// ExitLimit_clause is called when production limit_clause is exited. +func (s *BaseSnowflakeParserListener) ExitLimit_clause(ctx *Limit_clauseContext) {} + +// EnterSupplement_non_reserved_words is called when production supplement_non_reserved_words is entered. +func (s *BaseSnowflakeParserListener) EnterSupplement_non_reserved_words(ctx *Supplement_non_reserved_wordsContext) { +} + +// ExitSupplement_non_reserved_words is called when production supplement_non_reserved_words is exited. +func (s *BaseSnowflakeParserListener) ExitSupplement_non_reserved_words(ctx *Supplement_non_reserved_wordsContext) { +} diff --git a/snowflake/snowflakeparser_base_visitor.go b/snowflake/snowflakeparser_base_visitor.go new file mode 100644 index 0000000..4d41126 --- /dev/null +++ b/snowflake/snowflakeparser_base_visitor.go @@ -0,0 +1,2172 @@ +// Code generated from SnowflakeParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package snowflake // SnowflakeParser +import "github.com/antlr4-go/antlr/v4" + +type BaseSnowflakeParserVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BaseSnowflakeParserVisitor) VisitSnowflake_file(ctx *Snowflake_fileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitBatch(ctx *BatchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSql_command(ctx *Sql_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDdl_command(ctx *Ddl_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDml_command(ctx *Dml_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitInsert_statement(ctx *Insert_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitInsert_multi_table_statement(ctx *Insert_multi_table_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitInto_clause2(ctx *Into_clause2Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitValues_list(ctx *Values_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitValue_item(ctx *Value_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitMerge_statement(ctx *Merge_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitMerge_matches(ctx *Merge_matchesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitMerge_update_delete(ctx *Merge_update_deleteContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitMerge_insert(ctx *Merge_insertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUpdate_statement(ctx *Update_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTable_or_query(ctx *Table_or_queryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDelete_statement(ctx *Delete_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitValues_builder(ctx *Values_builderContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitOther_command(ctx *Other_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCopy_into_table(ctx *Copy_into_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExternal_location(ctx *External_locationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFiles(ctx *FilesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFile_format(ctx *File_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFormat_name(ctx *Format_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFormat_type(ctx *Format_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitStage_file_format(ctx *Stage_file_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCopy_into_location(ctx *Copy_into_locationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitComment(ctx *CommentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCommit(ctx *CommitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExecute_immediate(ctx *Execute_immediateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExecute_task(ctx *Execute_taskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExplain(ctx *ExplainContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitParallel(ctx *ParallelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGet_dml(ctx *Get_dmlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGrant_ownership(ctx *Grant_ownershipContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGrant_to_role(ctx *Grant_to_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGlobal_privileges(ctx *Global_privilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGlobal_privilege(ctx *Global_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAccount_object_privileges(ctx *Account_object_privilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAccount_object_privilege(ctx *Account_object_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSchema_privileges(ctx *Schema_privilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSchema_privilege(ctx *Schema_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSchema_object_privileges(ctx *Schema_object_privilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSchema_object_privilege(ctx *Schema_object_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGrant_to_share(ctx *Grant_to_shareContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_privilege(ctx *Object_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGrant_role(ctx *Grant_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRole_name(ctx *Role_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSystem_defined_role(ctx *System_defined_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitList(ctx *ListContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitInternal_stage(ctx *Internal_stageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExternal_stage(ctx *External_stageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPut(ctx *PutContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRemove(ctx *RemoveContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRevoke_from_role(ctx *Revoke_from_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRevoke_from_share(ctx *Revoke_from_shareContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRevoke_role(ctx *Revoke_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRollback(ctx *RollbackContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSet(ctx *SetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTruncate_materialized_view(ctx *Truncate_materialized_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTruncate_table(ctx *Truncate_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUnset(ctx *UnsetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_command(ctx *Alter_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAccount_params(ctx *Account_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_params(ctx *Object_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDefault_ddl_collation(ctx *Default_ddl_collationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_properties(ctx *Object_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSession_params(ctx *Session_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_account(ctx *Alter_accountContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitEnabled_true_false(ctx *Enabled_true_falseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_alert(ctx *Alter_alertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitResume_suspend(ctx *Resume_suspendContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlert_set_clause(ctx *Alert_set_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlert_unset_clause(ctx *Alert_unset_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_api_integration(ctx *Alter_api_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitApi_integration_property(ctx *Api_integration_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_connection(ctx *Alter_connectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_database(ctx *Alter_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDatabase_property(ctx *Database_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAccount_id_list(ctx *Account_id_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_dynamic_table(ctx *Alter_dynamic_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_external_table(ctx *Alter_external_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIgnore_edition_check(ctx *Ignore_edition_checkContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitReplication_schedule(ctx *Replication_scheduleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDb_name_list(ctx *Db_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShare_name_list(ctx *Share_name_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFull_acct_list(ctx *Full_acct_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_failover_group(ctx *Alter_failover_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_file_format(ctx *Alter_file_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_function(ctx *Alter_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_function_signature(ctx *Alter_function_signatureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitData_type_list(ctx *Data_type_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_masking_policy(ctx *Alter_masking_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_materialized_view(ctx *Alter_materialized_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_network_policy(ctx *Alter_network_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_notification_integration(ctx *Alter_notification_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_pipe(ctx *Alter_pipeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_procedure(ctx *Alter_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_replication_group(ctx *Alter_replication_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCredit_quota(ctx *Credit_quotaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFrequency(ctx *FrequencyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitNotify_users(ctx *Notify_usersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTriggerDefinition(ctx *TriggerDefinitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_resource_monitor(ctx *Alter_resource_monitorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_role(ctx *Alter_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_row_access_policy(ctx *Alter_row_access_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_schema(ctx *Alter_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSchema_property(ctx *Schema_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_security_integration(ctx *Alter_security_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_security_integration_external_oauth(ctx *Alter_security_integration_external_oauthContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSecurity_integration_external_oauth_property(ctx *Security_integration_external_oauth_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_security_integration_snowflake_oauth(ctx *Alter_security_integration_snowflake_oauthContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSecurity_integration_snowflake_oauth_property(ctx *Security_integration_snowflake_oauth_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_security_integration_saml2(ctx *Alter_security_integration_saml2Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_security_integration_scim(ctx *Alter_security_integration_scimContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSecurity_integration_scim_property(ctx *Security_integration_scim_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_sequence(ctx *Alter_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_session(ctx *Alter_sessionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_session_policy(ctx *Alter_session_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_share(ctx *Alter_shareContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_stage(ctx *Alter_stageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_storage_integration(ctx *Alter_storage_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_stream(ctx *Alter_streamContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_table(ctx *Alter_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitClustering_action(ctx *Clustering_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTable_column_action(ctx *Table_column_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitInline_constraint(ctx *Inline_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitConstraint_properties(ctx *Constraint_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExt_table_column_action(ctx *Ext_table_column_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitConstraint_action(ctx *Constraint_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSearch_optimization_action(ctx *Search_optimization_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSearch_method_with_target(ctx *Search_method_with_targetContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_table_alter_column(ctx *Alter_table_alter_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_column_decl_list(ctx *Alter_column_decl_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_column_decl(ctx *Alter_column_declContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_column_opts(ctx *Alter_column_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_set_tags(ctx *Column_set_tagsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_unset_tags(ctx *Column_unset_tagsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_tag(ctx *Alter_tagContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_task(ctx *Alter_taskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_user(ctx *Alter_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_view(ctx *Alter_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_modify(ctx *Alter_modifyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_warehouse(ctx *Alter_warehouseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_connection_opts(ctx *Alter_connection_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_user_opts(ctx *Alter_user_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_tag_opts(ctx *Alter_tag_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_network_policy_opts(ctx *Alter_network_policy_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_warehouse_opts(ctx *Alter_warehouse_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlter_account_opts(ctx *Alter_account_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSet_tags(ctx *Set_tagsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTag_decl_list(ctx *Tag_decl_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUnset_tags(ctx *Unset_tagsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_command(ctx *Create_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_account(ctx *Create_accountContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_alert(ctx *Create_alertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlert_condition(ctx *Alert_conditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlert_action(ctx *Alert_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_api_integration(ctx *Create_api_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_object_clone(ctx *Create_object_cloneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_connection(ctx *Create_connectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_database(ctx *Create_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_dynamic_table(ctx *Create_dynamic_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitClone_at_before(ctx *Clone_at_beforeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAt_before1(ctx *At_before1Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitHeader_decl(ctx *Header_declContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCompression_type(ctx *Compression_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCompression(ctx *CompressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_external_function(ctx *Create_external_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_external_table(ctx *Create_external_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExternal_table_column_decl(ctx *External_table_column_declContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExternal_table_column_decl_list(ctx *External_table_column_decl_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFull_acct(ctx *Full_acctContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIntegration_type_name(ctx *Integration_type_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_failover_group(ctx *Create_failover_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitType_fileformat(ctx *Type_fileformatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_file_format(ctx *Create_file_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitArg_decl(ctx *Arg_declContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCol_decl(ctx *Col_declContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFunction_definition(ctx *Function_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_function(ctx *Create_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_managed_account(ctx *Create_managed_accountContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_masking_policy(ctx *Create_masking_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTag_decl(ctx *Tag_declContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_list_in_parentheses(ctx *Column_list_in_parenthesesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_materialized_view(ctx *Create_materialized_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_network_policy(ctx *Create_network_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCloud_provider_params_auto(ctx *Cloud_provider_params_autoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCloud_provider_params_push(ctx *Cloud_provider_params_pushContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_notification_integration(ctx *Create_notification_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_pipe(ctx *Create_pipeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCaller_owner(ctx *Caller_ownerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExecuta_as(ctx *Executa_asContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitProcedure_definition(ctx *Procedure_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_procedure(ctx *Create_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_replication_group(ctx *Create_replication_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_resource_monitor(ctx *Create_resource_monitorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_role(ctx *Create_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_row_access_policy(ctx *Create_row_access_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_schema(ctx *Create_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_security_integration_external_oauth(ctx *Create_security_integration_external_oauthContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitImplicit_none(ctx *Implicit_noneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_security_integration_snowflake_oauth(ctx *Create_security_integration_snowflake_oauthContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_security_integration_saml2(ctx *Create_security_integration_saml2Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_security_integration_scim(ctx *Create_security_integration_scimContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitNetwork_policy(ctx *Network_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPartner_application(ctx *Partner_applicationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitStart_with(ctx *Start_withContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIncrement_by(ctx *Increment_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_sequence(ctx *Create_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_session_policy(ctx *Create_session_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_share(ctx *Create_shareContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCharacter(ctx *CharacterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFormat_type_options(ctx *Format_type_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCopy_options(ctx *Copy_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitInternal_stage_params(ctx *Internal_stage_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitStage_type(ctx *Stage_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitStage_master_key(ctx *Stage_master_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitStage_kms_key(ctx *Stage_kms_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitStage_encryption_opts_aws(ctx *Stage_encryption_opts_awsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAws_token(ctx *Aws_tokenContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAws_key_id(ctx *Aws_key_idContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAws_secret_key(ctx *Aws_secret_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAws_role(ctx *Aws_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExternal_stage_params(ctx *External_stage_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTrue_false(ctx *True_falseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitEnable(ctx *EnableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRefresh_on_create(ctx *Refresh_on_createContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAuto_refresh(ctx *Auto_refreshContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitNotification_integration(ctx *Notification_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDirectory_table_params(ctx *Directory_table_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_stage(ctx *Create_stageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCloud_provider_params(ctx *Cloud_provider_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCloud_provider_params2(ctx *Cloud_provider_params2Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCloud_provider_params3(ctx *Cloud_provider_params3Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_storage_integration(ctx *Create_storage_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCopy_grants(ctx *Copy_grantsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAppend_only(ctx *Append_onlyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitInsert_only(ctx *Insert_onlyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_initial_rows(ctx *Show_initial_rowsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitStream_time(ctx *Stream_timeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_stream(ctx *Create_streamContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTemporary(ctx *TemporaryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTable_type(ctx *Table_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitWith_tags(ctx *With_tagsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitWith_row_access_policy(ctx *With_row_access_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCluster_by(ctx *Cluster_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitChange_tracking(ctx *Change_trackingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitWith_masking_policy(ctx *With_masking_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCollate(ctx *CollateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitNot_null(ctx *Not_nullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDefault_value(ctx *Default_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitForeign_key(ctx *Foreign_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitOut_of_line_constraint(ctx *Out_of_line_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFull_col_decl(ctx *Full_col_declContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_decl_item(ctx *Column_decl_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_decl_item_list(ctx *Column_decl_item_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_table(ctx *Create_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_table_as_select(ctx *Create_table_as_selectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_tag(ctx *Create_tagContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSession_parameter(ctx *Session_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSession_parameter_list(ctx *Session_parameter_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSession_parameter_init_list(ctx *Session_parameter_init_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSession_parameter_init(ctx *Session_parameter_initContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_task(ctx *Create_taskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSql(ctx *SqlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCall(ctx *CallContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_user(ctx *Create_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitView_col(ctx *View_colContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_view(ctx *Create_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCreate_warehouse(ctx *Create_warehouseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitWh_properties(ctx *Wh_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitWh_params(ctx *Wh_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTrigger_definition(ctx *Trigger_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_type_name(ctx *Object_type_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_type_plural(ctx *Object_type_pluralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_command(ctx *Drop_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_object(ctx *Drop_objectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_alert(ctx *Drop_alertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_connection(ctx *Drop_connectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_database(ctx *Drop_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_dynamic_table(ctx *Drop_dynamic_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_external_table(ctx *Drop_external_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_failover_group(ctx *Drop_failover_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_file_format(ctx *Drop_file_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_function(ctx *Drop_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_integration(ctx *Drop_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_managed_account(ctx *Drop_managed_accountContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_masking_policy(ctx *Drop_masking_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_materialized_view(ctx *Drop_materialized_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_network_policy(ctx *Drop_network_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_pipe(ctx *Drop_pipeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_procedure(ctx *Drop_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_replication_group(ctx *Drop_replication_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_resource_monitor(ctx *Drop_resource_monitorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_role(ctx *Drop_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_row_access_policy(ctx *Drop_row_access_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_schema(ctx *Drop_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_sequence(ctx *Drop_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_session_policy(ctx *Drop_session_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_share(ctx *Drop_shareContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_stage(ctx *Drop_stageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_stream(ctx *Drop_streamContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_table(ctx *Drop_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_tag(ctx *Drop_tagContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_task(ctx *Drop_taskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_user(ctx *Drop_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_view(ctx *Drop_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDrop_warehouse(ctx *Drop_warehouseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCascade_restrict(ctx *Cascade_restrictContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitArg_types(ctx *Arg_typesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUndrop_command(ctx *Undrop_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUndrop_database(ctx *Undrop_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUndrop_dynamic_table(ctx *Undrop_dynamic_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUndrop_schema(ctx *Undrop_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUndrop_table(ctx *Undrop_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUndrop_tag(ctx *Undrop_tagContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUse_command(ctx *Use_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUse_database(ctx *Use_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUse_role(ctx *Use_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUse_schema(ctx *Use_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUse_secondary_roles(ctx *Use_secondary_rolesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitUse_warehouse(ctx *Use_warehouseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitComment_clause(ctx *Comment_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIf_suspended(ctx *If_suspendedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIf_exists(ctx *If_existsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIf_not_exists(ctx *If_not_existsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitOr_replace(ctx *Or_replaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe(ctx *DescribeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_command(ctx *Describe_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_alert(ctx *Describe_alertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_database(ctx *Describe_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_dynamic_table(ctx *Describe_dynamic_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_external_table(ctx *Describe_external_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_file_format(ctx *Describe_file_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_function(ctx *Describe_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_integration(ctx *Describe_integrationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_masking_policy(ctx *Describe_masking_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_materialized_view(ctx *Describe_materialized_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_network_policy(ctx *Describe_network_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_pipe(ctx *Describe_pipeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_procedure(ctx *Describe_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_result(ctx *Describe_resultContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_row_access_policy(ctx *Describe_row_access_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_schema(ctx *Describe_schemaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_search_optimization(ctx *Describe_search_optimizationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_sequence(ctx *Describe_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_session_policy(ctx *Describe_session_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_share(ctx *Describe_shareContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_stage(ctx *Describe_stageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_stream(ctx *Describe_streamContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_table(ctx *Describe_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_task(ctx *Describe_taskContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_transaction(ctx *Describe_transactionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_user(ctx *Describe_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_view(ctx *Describe_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDescribe_warehouse(ctx *Describe_warehouseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_command(ctx *Show_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_alerts(ctx *Show_alertsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_columns(ctx *Show_columnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_connections(ctx *Show_connectionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitStarts_with(ctx *Starts_withContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitLimit_rows(ctx *Limit_rowsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_databases(ctx *Show_databasesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_databases_in_failover_group(ctx *Show_databases_in_failover_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_databases_in_replication_group(ctx *Show_databases_in_replication_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_delegated_authorizations(ctx *Show_delegated_authorizationsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_external_functions(ctx *Show_external_functionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_dynamic_tables(ctx *Show_dynamic_tablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_external_tables(ctx *Show_external_tablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_failover_groups(ctx *Show_failover_groupsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_file_formats(ctx *Show_file_formatsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_functions(ctx *Show_functionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_global_accounts(ctx *Show_global_accountsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_grants(ctx *Show_grantsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_grants_opts(ctx *Show_grants_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_integrations(ctx *Show_integrationsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_locks(ctx *Show_locksContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_managed_accounts(ctx *Show_managed_accountsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_masking_policies(ctx *Show_masking_policiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIn_obj(ctx *In_objContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIn_obj_2(ctx *In_obj_2Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_materialized_views(ctx *Show_materialized_viewsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_network_policies(ctx *Show_network_policiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_objects(ctx *Show_objectsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_organization_accounts(ctx *Show_organization_accountsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIn_for(ctx *In_forContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_parameters(ctx *Show_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_pipes(ctx *Show_pipesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_primary_keys(ctx *Show_primary_keysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_procedures(ctx *Show_proceduresContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_regions(ctx *Show_regionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_replication_accounts(ctx *Show_replication_accountsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_replication_databases(ctx *Show_replication_databasesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_replication_groups(ctx *Show_replication_groupsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_resource_monitors(ctx *Show_resource_monitorsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_roles(ctx *Show_rolesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_row_access_policies(ctx *Show_row_access_policiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_schemas(ctx *Show_schemasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_sequences(ctx *Show_sequencesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_session_policies(ctx *Show_session_policiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_shares(ctx *Show_sharesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_shares_in_failover_group(ctx *Show_shares_in_failover_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_shares_in_replication_group(ctx *Show_shares_in_replication_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_stages(ctx *Show_stagesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_streams(ctx *Show_streamsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_tables(ctx *Show_tablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_tags(ctx *Show_tagsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_tasks(ctx *Show_tasksContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_transactions(ctx *Show_transactionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_user_functions(ctx *Show_user_functionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_users(ctx *Show_usersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_variables(ctx *Show_variablesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_views(ctx *Show_viewsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitShow_warehouses(ctx *Show_warehousesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitLike_pattern(ctx *Like_patternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAccount_identifier(ctx *Account_identifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSchema_name(ctx *Schema_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_type(ctx *Object_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_type_list(ctx *Object_type_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTag_value(ctx *Tag_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitArg_data_type(ctx *Arg_data_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitArg_name(ctx *Arg_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitParam_name(ctx *Param_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRegion_group_id(ctx *Region_group_idContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSnowflake_region_id(ctx *Snowflake_region_idContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitString(ctx *StringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitString_list(ctx *String_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitId_(ctx *Id_Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitKeyword(ctx *KeywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitNon_reserved_words(ctx *Non_reserved_wordsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitBuiltin_function(ctx *Builtin_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitList_operator(ctx *List_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitBinary_builtin_function(ctx *Binary_builtin_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitBinary_or_ternary_builtin_function(ctx *Binary_or_ternary_builtin_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTernary_builtin_function(ctx *Ternary_builtin_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPattern(ctx *PatternContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_name(ctx *Column_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_list(ctx *Column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_name(ctx *Object_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitNum(ctx *NumContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExpr_list(ctx *Expr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExpr_list_sorted(ctx *Expr_list_sortedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExpr(ctx *ExprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitIff_expr(ctx *Iff_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTrim_expression(ctx *Trim_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTry_cast_expr(ctx *Try_cast_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitJson_literal(ctx *Json_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitKv_pair(ctx *Kv_pairContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitValue(ctx *ValueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitArr_literal(ctx *Arr_literalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitData_type(ctx *Data_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPrimitive_expression(ctx *Primitive_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitOrder_by_expr(ctx *Order_by_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAsc_desc(ctx *Asc_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitOver_clause(ctx *Over_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFunction_call(ctx *Function_callContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRanking_windowed_function(ctx *Ranking_windowed_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAggregate_function(ctx *Aggregate_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitLiteral(ctx *LiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSign(ctx *SignContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFull_column_name(ctx *Full_column_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitBracket_expression(ctx *Bracket_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCase_expression(ctx *Case_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSwitch_search_condition_section(ctx *Switch_search_condition_sectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSwitch_section(ctx *Switch_sectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitQuery_statement(ctx *Query_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitWith_expression(ctx *With_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitCommon_table_expression(ctx *Common_table_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAnchor_clause(ctx *Anchor_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRecursive_clause(ctx *Recursive_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSelect_statement(ctx *Select_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSet_operators(ctx *Set_operatorsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSelect_optional_clauses(ctx *Select_optional_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSelect_clause(ctx *Select_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSelect_top_clause(ctx *Select_top_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSelect_list_no_top(ctx *Select_list_no_topContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSelect_list_top(ctx *Select_list_topContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSelect_list(ctx *Select_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSelect_list_elem(ctx *Select_list_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_elem(ctx *Column_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAs_alias(ctx *As_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExpression_elem(ctx *Expression_elemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_position(ctx *Column_positionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAll_distinct(ctx *All_distinctContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTop_clause(ctx *Top_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitInto_clause(ctx *Into_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitVar_list(ctx *Var_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitVar(ctx *VarContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFrom_clause(ctx *From_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTable_sources(ctx *Table_sourcesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTable_source(ctx *Table_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitTable_source_item_joined(ctx *Table_source_item_joinedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitObject_ref(ctx *Object_refContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFlatten_table_option(ctx *Flatten_table_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFlatten_table(ctx *Flatten_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPrior_list(ctx *Prior_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPrior_item(ctx *Prior_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitOuter_join(ctx *Outer_joinContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitJoin_type(ctx *Join_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitJoin_clause(ctx *Join_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAt_before(ctx *At_beforeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitEnd(ctx *EndContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitChanges(ctx *ChangesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDefault_append_only(ctx *Default_append_onlyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPartition_by(ctx *Partition_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAlias(ctx *AliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExpr_alias_list(ctx *Expr_alias_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitMeasures(ctx *MeasuresContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitMatch_opts(ctx *Match_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRow_match(ctx *Row_matchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFirst_last(ctx *First_lastContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSymbol(ctx *SymbolContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitAfter_match(ctx *After_matchContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSymbol_list(ctx *Symbol_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitDefine(ctx *DefineContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitMatch_recognize(ctx *Match_recognizeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPivot_unpivot(ctx *Pivot_unpivotContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitColumn_alias_list_in_brackets(ctx *Column_alias_list_in_bracketsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitExpr_list_in_parentheses(ctx *Expr_list_in_parenthesesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitValues(ctx *ValuesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSample_method(ctx *Sample_methodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRepeatable_seed(ctx *Repeatable_seedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSample_opts(ctx *Sample_optsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSample(ctx *SampleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSearch_condition(ctx *Search_conditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitComparison_operator(ctx *Comparison_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitNull_not_null(ctx *Null_not_nullContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSubquery(ctx *SubqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitPredicate(ctx *PredicateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitWhere_clause(ctx *Where_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGroup_item(ctx *Group_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitGroup_by_clause(ctx *Group_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitHaving_clause(ctx *Having_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitQualify_clause(ctx *Qualify_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitOrder_item(ctx *Order_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitOrder_by_clause(ctx *Order_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitRow_rows(ctx *Row_rowsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitFirst_next(ctx *First_nextContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitLimit_clause(ctx *Limit_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BaseSnowflakeParserVisitor) VisitSupplement_non_reserved_words(ctx *Supplement_non_reserved_wordsContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/snowflake/snowflakeparser_listener.go b/snowflake/snowflakeparser_listener.go new file mode 100644 index 0000000..1809387 --- /dev/null +++ b/snowflake/snowflakeparser_listener.go @@ -0,0 +1,3255 @@ +// Code generated from SnowflakeParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package snowflake // SnowflakeParser +import "github.com/antlr4-go/antlr/v4" + +// SnowflakeParserListener is a complete listener for a parse tree produced by SnowflakeParser. +type SnowflakeParserListener interface { + antlr.ParseTreeListener + + // EnterSnowflake_file is called when entering the snowflake_file production. + EnterSnowflake_file(c *Snowflake_fileContext) + + // EnterBatch is called when entering the batch production. + EnterBatch(c *BatchContext) + + // EnterSql_command is called when entering the sql_command production. + EnterSql_command(c *Sql_commandContext) + + // EnterDdl_command is called when entering the ddl_command production. + EnterDdl_command(c *Ddl_commandContext) + + // EnterDml_command is called when entering the dml_command production. + EnterDml_command(c *Dml_commandContext) + + // EnterInsert_statement is called when entering the insert_statement production. + EnterInsert_statement(c *Insert_statementContext) + + // EnterInsert_multi_table_statement is called when entering the insert_multi_table_statement production. + EnterInsert_multi_table_statement(c *Insert_multi_table_statementContext) + + // EnterInto_clause2 is called when entering the into_clause2 production. + EnterInto_clause2(c *Into_clause2Context) + + // EnterValues_list is called when entering the values_list production. + EnterValues_list(c *Values_listContext) + + // EnterValue_item is called when entering the value_item production. + EnterValue_item(c *Value_itemContext) + + // EnterMerge_statement is called when entering the merge_statement production. + EnterMerge_statement(c *Merge_statementContext) + + // EnterMerge_matches is called when entering the merge_matches production. + EnterMerge_matches(c *Merge_matchesContext) + + // EnterMerge_update_delete is called when entering the merge_update_delete production. + EnterMerge_update_delete(c *Merge_update_deleteContext) + + // EnterMerge_insert is called when entering the merge_insert production. + EnterMerge_insert(c *Merge_insertContext) + + // EnterUpdate_statement is called when entering the update_statement production. + EnterUpdate_statement(c *Update_statementContext) + + // EnterTable_or_query is called when entering the table_or_query production. + EnterTable_or_query(c *Table_or_queryContext) + + // EnterDelete_statement is called when entering the delete_statement production. + EnterDelete_statement(c *Delete_statementContext) + + // EnterValues_builder is called when entering the values_builder production. + EnterValues_builder(c *Values_builderContext) + + // EnterOther_command is called when entering the other_command production. + EnterOther_command(c *Other_commandContext) + + // EnterCopy_into_table is called when entering the copy_into_table production. + EnterCopy_into_table(c *Copy_into_tableContext) + + // EnterExternal_location is called when entering the external_location production. + EnterExternal_location(c *External_locationContext) + + // EnterFiles is called when entering the files production. + EnterFiles(c *FilesContext) + + // EnterFile_format is called when entering the file_format production. + EnterFile_format(c *File_formatContext) + + // EnterFormat_name is called when entering the format_name production. + EnterFormat_name(c *Format_nameContext) + + // EnterFormat_type is called when entering the format_type production. + EnterFormat_type(c *Format_typeContext) + + // EnterStage_file_format is called when entering the stage_file_format production. + EnterStage_file_format(c *Stage_file_formatContext) + + // EnterCopy_into_location is called when entering the copy_into_location production. + EnterCopy_into_location(c *Copy_into_locationContext) + + // EnterComment is called when entering the comment production. + EnterComment(c *CommentContext) + + // EnterCommit is called when entering the commit production. + EnterCommit(c *CommitContext) + + // EnterExecute_immediate is called when entering the execute_immediate production. + EnterExecute_immediate(c *Execute_immediateContext) + + // EnterExecute_task is called when entering the execute_task production. + EnterExecute_task(c *Execute_taskContext) + + // EnterExplain is called when entering the explain production. + EnterExplain(c *ExplainContext) + + // EnterParallel is called when entering the parallel production. + EnterParallel(c *ParallelContext) + + // EnterGet_dml is called when entering the get_dml production. + EnterGet_dml(c *Get_dmlContext) + + // EnterGrant_ownership is called when entering the grant_ownership production. + EnterGrant_ownership(c *Grant_ownershipContext) + + // EnterGrant_to_role is called when entering the grant_to_role production. + EnterGrant_to_role(c *Grant_to_roleContext) + + // EnterGlobal_privileges is called when entering the global_privileges production. + EnterGlobal_privileges(c *Global_privilegesContext) + + // EnterGlobal_privilege is called when entering the global_privilege production. + EnterGlobal_privilege(c *Global_privilegeContext) + + // EnterAccount_object_privileges is called when entering the account_object_privileges production. + EnterAccount_object_privileges(c *Account_object_privilegesContext) + + // EnterAccount_object_privilege is called when entering the account_object_privilege production. + EnterAccount_object_privilege(c *Account_object_privilegeContext) + + // EnterSchema_privileges is called when entering the schema_privileges production. + EnterSchema_privileges(c *Schema_privilegesContext) + + // EnterSchema_privilege is called when entering the schema_privilege production. + EnterSchema_privilege(c *Schema_privilegeContext) + + // EnterSchema_object_privileges is called when entering the schema_object_privileges production. + EnterSchema_object_privileges(c *Schema_object_privilegesContext) + + // EnterSchema_object_privilege is called when entering the schema_object_privilege production. + EnterSchema_object_privilege(c *Schema_object_privilegeContext) + + // EnterGrant_to_share is called when entering the grant_to_share production. + EnterGrant_to_share(c *Grant_to_shareContext) + + // EnterObject_privilege is called when entering the object_privilege production. + EnterObject_privilege(c *Object_privilegeContext) + + // EnterGrant_role is called when entering the grant_role production. + EnterGrant_role(c *Grant_roleContext) + + // EnterRole_name is called when entering the role_name production. + EnterRole_name(c *Role_nameContext) + + // EnterSystem_defined_role is called when entering the system_defined_role production. + EnterSystem_defined_role(c *System_defined_roleContext) + + // EnterList is called when entering the list production. + EnterList(c *ListContext) + + // EnterInternal_stage is called when entering the internal_stage production. + EnterInternal_stage(c *Internal_stageContext) + + // EnterExternal_stage is called when entering the external_stage production. + EnterExternal_stage(c *External_stageContext) + + // EnterPut is called when entering the put production. + EnterPut(c *PutContext) + + // EnterRemove is called when entering the remove production. + EnterRemove(c *RemoveContext) + + // EnterRevoke_from_role is called when entering the revoke_from_role production. + EnterRevoke_from_role(c *Revoke_from_roleContext) + + // EnterRevoke_from_share is called when entering the revoke_from_share production. + EnterRevoke_from_share(c *Revoke_from_shareContext) + + // EnterRevoke_role is called when entering the revoke_role production. + EnterRevoke_role(c *Revoke_roleContext) + + // EnterRollback is called when entering the rollback production. + EnterRollback(c *RollbackContext) + + // EnterSet is called when entering the set production. + EnterSet(c *SetContext) + + // EnterTruncate_materialized_view is called when entering the truncate_materialized_view production. + EnterTruncate_materialized_view(c *Truncate_materialized_viewContext) + + // EnterTruncate_table is called when entering the truncate_table production. + EnterTruncate_table(c *Truncate_tableContext) + + // EnterUnset is called when entering the unset production. + EnterUnset(c *UnsetContext) + + // EnterAlter_command is called when entering the alter_command production. + EnterAlter_command(c *Alter_commandContext) + + // EnterAccount_params is called when entering the account_params production. + EnterAccount_params(c *Account_paramsContext) + + // EnterObject_params is called when entering the object_params production. + EnterObject_params(c *Object_paramsContext) + + // EnterDefault_ddl_collation is called when entering the default_ddl_collation production. + EnterDefault_ddl_collation(c *Default_ddl_collationContext) + + // EnterObject_properties is called when entering the object_properties production. + EnterObject_properties(c *Object_propertiesContext) + + // EnterSession_params is called when entering the session_params production. + EnterSession_params(c *Session_paramsContext) + + // EnterAlter_account is called when entering the alter_account production. + EnterAlter_account(c *Alter_accountContext) + + // EnterEnabled_true_false is called when entering the enabled_true_false production. + EnterEnabled_true_false(c *Enabled_true_falseContext) + + // EnterAlter_alert is called when entering the alter_alert production. + EnterAlter_alert(c *Alter_alertContext) + + // EnterResume_suspend is called when entering the resume_suspend production. + EnterResume_suspend(c *Resume_suspendContext) + + // EnterAlert_set_clause is called when entering the alert_set_clause production. + EnterAlert_set_clause(c *Alert_set_clauseContext) + + // EnterAlert_unset_clause is called when entering the alert_unset_clause production. + EnterAlert_unset_clause(c *Alert_unset_clauseContext) + + // EnterAlter_api_integration is called when entering the alter_api_integration production. + EnterAlter_api_integration(c *Alter_api_integrationContext) + + // EnterApi_integration_property is called when entering the api_integration_property production. + EnterApi_integration_property(c *Api_integration_propertyContext) + + // EnterAlter_connection is called when entering the alter_connection production. + EnterAlter_connection(c *Alter_connectionContext) + + // EnterAlter_database is called when entering the alter_database production. + EnterAlter_database(c *Alter_databaseContext) + + // EnterDatabase_property is called when entering the database_property production. + EnterDatabase_property(c *Database_propertyContext) + + // EnterAccount_id_list is called when entering the account_id_list production. + EnterAccount_id_list(c *Account_id_listContext) + + // EnterAlter_dynamic_table is called when entering the alter_dynamic_table production. + EnterAlter_dynamic_table(c *Alter_dynamic_tableContext) + + // EnterAlter_external_table is called when entering the alter_external_table production. + EnterAlter_external_table(c *Alter_external_tableContext) + + // EnterIgnore_edition_check is called when entering the ignore_edition_check production. + EnterIgnore_edition_check(c *Ignore_edition_checkContext) + + // EnterReplication_schedule is called when entering the replication_schedule production. + EnterReplication_schedule(c *Replication_scheduleContext) + + // EnterDb_name_list is called when entering the db_name_list production. + EnterDb_name_list(c *Db_name_listContext) + + // EnterShare_name_list is called when entering the share_name_list production. + EnterShare_name_list(c *Share_name_listContext) + + // EnterFull_acct_list is called when entering the full_acct_list production. + EnterFull_acct_list(c *Full_acct_listContext) + + // EnterAlter_failover_group is called when entering the alter_failover_group production. + EnterAlter_failover_group(c *Alter_failover_groupContext) + + // EnterAlter_file_format is called when entering the alter_file_format production. + EnterAlter_file_format(c *Alter_file_formatContext) + + // EnterAlter_function is called when entering the alter_function production. + EnterAlter_function(c *Alter_functionContext) + + // EnterAlter_function_signature is called when entering the alter_function_signature production. + EnterAlter_function_signature(c *Alter_function_signatureContext) + + // EnterData_type_list is called when entering the data_type_list production. + EnterData_type_list(c *Data_type_listContext) + + // EnterAlter_masking_policy is called when entering the alter_masking_policy production. + EnterAlter_masking_policy(c *Alter_masking_policyContext) + + // EnterAlter_materialized_view is called when entering the alter_materialized_view production. + EnterAlter_materialized_view(c *Alter_materialized_viewContext) + + // EnterAlter_network_policy is called when entering the alter_network_policy production. + EnterAlter_network_policy(c *Alter_network_policyContext) + + // EnterAlter_notification_integration is called when entering the alter_notification_integration production. + EnterAlter_notification_integration(c *Alter_notification_integrationContext) + + // EnterAlter_pipe is called when entering the alter_pipe production. + EnterAlter_pipe(c *Alter_pipeContext) + + // EnterAlter_procedure is called when entering the alter_procedure production. + EnterAlter_procedure(c *Alter_procedureContext) + + // EnterAlter_replication_group is called when entering the alter_replication_group production. + EnterAlter_replication_group(c *Alter_replication_groupContext) + + // EnterCredit_quota is called when entering the credit_quota production. + EnterCredit_quota(c *Credit_quotaContext) + + // EnterFrequency is called when entering the frequency production. + EnterFrequency(c *FrequencyContext) + + // EnterNotify_users is called when entering the notify_users production. + EnterNotify_users(c *Notify_usersContext) + + // EnterTriggerDefinition is called when entering the triggerDefinition production. + EnterTriggerDefinition(c *TriggerDefinitionContext) + + // EnterAlter_resource_monitor is called when entering the alter_resource_monitor production. + EnterAlter_resource_monitor(c *Alter_resource_monitorContext) + + // EnterAlter_role is called when entering the alter_role production. + EnterAlter_role(c *Alter_roleContext) + + // EnterAlter_row_access_policy is called when entering the alter_row_access_policy production. + EnterAlter_row_access_policy(c *Alter_row_access_policyContext) + + // EnterAlter_schema is called when entering the alter_schema production. + EnterAlter_schema(c *Alter_schemaContext) + + // EnterSchema_property is called when entering the schema_property production. + EnterSchema_property(c *Schema_propertyContext) + + // EnterAlter_security_integration is called when entering the alter_security_integration production. + EnterAlter_security_integration(c *Alter_security_integrationContext) + + // EnterAlter_security_integration_external_oauth is called when entering the alter_security_integration_external_oauth production. + EnterAlter_security_integration_external_oauth(c *Alter_security_integration_external_oauthContext) + + // EnterSecurity_integration_external_oauth_property is called when entering the security_integration_external_oauth_property production. + EnterSecurity_integration_external_oauth_property(c *Security_integration_external_oauth_propertyContext) + + // EnterAlter_security_integration_snowflake_oauth is called when entering the alter_security_integration_snowflake_oauth production. + EnterAlter_security_integration_snowflake_oauth(c *Alter_security_integration_snowflake_oauthContext) + + // EnterSecurity_integration_snowflake_oauth_property is called when entering the security_integration_snowflake_oauth_property production. + EnterSecurity_integration_snowflake_oauth_property(c *Security_integration_snowflake_oauth_propertyContext) + + // EnterAlter_security_integration_saml2 is called when entering the alter_security_integration_saml2 production. + EnterAlter_security_integration_saml2(c *Alter_security_integration_saml2Context) + + // EnterAlter_security_integration_scim is called when entering the alter_security_integration_scim production. + EnterAlter_security_integration_scim(c *Alter_security_integration_scimContext) + + // EnterSecurity_integration_scim_property is called when entering the security_integration_scim_property production. + EnterSecurity_integration_scim_property(c *Security_integration_scim_propertyContext) + + // EnterAlter_sequence is called when entering the alter_sequence production. + EnterAlter_sequence(c *Alter_sequenceContext) + + // EnterAlter_session is called when entering the alter_session production. + EnterAlter_session(c *Alter_sessionContext) + + // EnterAlter_session_policy is called when entering the alter_session_policy production. + EnterAlter_session_policy(c *Alter_session_policyContext) + + // EnterAlter_share is called when entering the alter_share production. + EnterAlter_share(c *Alter_shareContext) + + // EnterAlter_stage is called when entering the alter_stage production. + EnterAlter_stage(c *Alter_stageContext) + + // EnterAlter_storage_integration is called when entering the alter_storage_integration production. + EnterAlter_storage_integration(c *Alter_storage_integrationContext) + + // EnterAlter_stream is called when entering the alter_stream production. + EnterAlter_stream(c *Alter_streamContext) + + // EnterAlter_table is called when entering the alter_table production. + EnterAlter_table(c *Alter_tableContext) + + // EnterClustering_action is called when entering the clustering_action production. + EnterClustering_action(c *Clustering_actionContext) + + // EnterTable_column_action is called when entering the table_column_action production. + EnterTable_column_action(c *Table_column_actionContext) + + // EnterInline_constraint is called when entering the inline_constraint production. + EnterInline_constraint(c *Inline_constraintContext) + + // EnterConstraint_properties is called when entering the constraint_properties production. + EnterConstraint_properties(c *Constraint_propertiesContext) + + // EnterExt_table_column_action is called when entering the ext_table_column_action production. + EnterExt_table_column_action(c *Ext_table_column_actionContext) + + // EnterConstraint_action is called when entering the constraint_action production. + EnterConstraint_action(c *Constraint_actionContext) + + // EnterSearch_optimization_action is called when entering the search_optimization_action production. + EnterSearch_optimization_action(c *Search_optimization_actionContext) + + // EnterSearch_method_with_target is called when entering the search_method_with_target production. + EnterSearch_method_with_target(c *Search_method_with_targetContext) + + // EnterAlter_table_alter_column is called when entering the alter_table_alter_column production. + EnterAlter_table_alter_column(c *Alter_table_alter_columnContext) + + // EnterAlter_column_decl_list is called when entering the alter_column_decl_list production. + EnterAlter_column_decl_list(c *Alter_column_decl_listContext) + + // EnterAlter_column_decl is called when entering the alter_column_decl production. + EnterAlter_column_decl(c *Alter_column_declContext) + + // EnterAlter_column_opts is called when entering the alter_column_opts production. + EnterAlter_column_opts(c *Alter_column_optsContext) + + // EnterColumn_set_tags is called when entering the column_set_tags production. + EnterColumn_set_tags(c *Column_set_tagsContext) + + // EnterColumn_unset_tags is called when entering the column_unset_tags production. + EnterColumn_unset_tags(c *Column_unset_tagsContext) + + // EnterAlter_tag is called when entering the alter_tag production. + EnterAlter_tag(c *Alter_tagContext) + + // EnterAlter_task is called when entering the alter_task production. + EnterAlter_task(c *Alter_taskContext) + + // EnterAlter_user is called when entering the alter_user production. + EnterAlter_user(c *Alter_userContext) + + // EnterAlter_view is called when entering the alter_view production. + EnterAlter_view(c *Alter_viewContext) + + // EnterAlter_modify is called when entering the alter_modify production. + EnterAlter_modify(c *Alter_modifyContext) + + // EnterAlter_warehouse is called when entering the alter_warehouse production. + EnterAlter_warehouse(c *Alter_warehouseContext) + + // EnterAlter_connection_opts is called when entering the alter_connection_opts production. + EnterAlter_connection_opts(c *Alter_connection_optsContext) + + // EnterAlter_user_opts is called when entering the alter_user_opts production. + EnterAlter_user_opts(c *Alter_user_optsContext) + + // EnterAlter_tag_opts is called when entering the alter_tag_opts production. + EnterAlter_tag_opts(c *Alter_tag_optsContext) + + // EnterAlter_network_policy_opts is called when entering the alter_network_policy_opts production. + EnterAlter_network_policy_opts(c *Alter_network_policy_optsContext) + + // EnterAlter_warehouse_opts is called when entering the alter_warehouse_opts production. + EnterAlter_warehouse_opts(c *Alter_warehouse_optsContext) + + // EnterAlter_account_opts is called when entering the alter_account_opts production. + EnterAlter_account_opts(c *Alter_account_optsContext) + + // EnterSet_tags is called when entering the set_tags production. + EnterSet_tags(c *Set_tagsContext) + + // EnterTag_decl_list is called when entering the tag_decl_list production. + EnterTag_decl_list(c *Tag_decl_listContext) + + // EnterUnset_tags is called when entering the unset_tags production. + EnterUnset_tags(c *Unset_tagsContext) + + // EnterCreate_command is called when entering the create_command production. + EnterCreate_command(c *Create_commandContext) + + // EnterCreate_account is called when entering the create_account production. + EnterCreate_account(c *Create_accountContext) + + // EnterCreate_alert is called when entering the create_alert production. + EnterCreate_alert(c *Create_alertContext) + + // EnterAlert_condition is called when entering the alert_condition production. + EnterAlert_condition(c *Alert_conditionContext) + + // EnterAlert_action is called when entering the alert_action production. + EnterAlert_action(c *Alert_actionContext) + + // EnterCreate_api_integration is called when entering the create_api_integration production. + EnterCreate_api_integration(c *Create_api_integrationContext) + + // EnterCreate_object_clone is called when entering the create_object_clone production. + EnterCreate_object_clone(c *Create_object_cloneContext) + + // EnterCreate_connection is called when entering the create_connection production. + EnterCreate_connection(c *Create_connectionContext) + + // EnterCreate_database is called when entering the create_database production. + EnterCreate_database(c *Create_databaseContext) + + // EnterCreate_dynamic_table is called when entering the create_dynamic_table production. + EnterCreate_dynamic_table(c *Create_dynamic_tableContext) + + // EnterClone_at_before is called when entering the clone_at_before production. + EnterClone_at_before(c *Clone_at_beforeContext) + + // EnterAt_before1 is called when entering the at_before1 production. + EnterAt_before1(c *At_before1Context) + + // EnterHeader_decl is called when entering the header_decl production. + EnterHeader_decl(c *Header_declContext) + + // EnterCompression_type is called when entering the compression_type production. + EnterCompression_type(c *Compression_typeContext) + + // EnterCompression is called when entering the compression production. + EnterCompression(c *CompressionContext) + + // EnterCreate_external_function is called when entering the create_external_function production. + EnterCreate_external_function(c *Create_external_functionContext) + + // EnterCreate_external_table is called when entering the create_external_table production. + EnterCreate_external_table(c *Create_external_tableContext) + + // EnterExternal_table_column_decl is called when entering the external_table_column_decl production. + EnterExternal_table_column_decl(c *External_table_column_declContext) + + // EnterExternal_table_column_decl_list is called when entering the external_table_column_decl_list production. + EnterExternal_table_column_decl_list(c *External_table_column_decl_listContext) + + // EnterFull_acct is called when entering the full_acct production. + EnterFull_acct(c *Full_acctContext) + + // EnterIntegration_type_name is called when entering the integration_type_name production. + EnterIntegration_type_name(c *Integration_type_nameContext) + + // EnterCreate_failover_group is called when entering the create_failover_group production. + EnterCreate_failover_group(c *Create_failover_groupContext) + + // EnterType_fileformat is called when entering the type_fileformat production. + EnterType_fileformat(c *Type_fileformatContext) + + // EnterCreate_file_format is called when entering the create_file_format production. + EnterCreate_file_format(c *Create_file_formatContext) + + // EnterArg_decl is called when entering the arg_decl production. + EnterArg_decl(c *Arg_declContext) + + // EnterCol_decl is called when entering the col_decl production. + EnterCol_decl(c *Col_declContext) + + // EnterFunction_definition is called when entering the function_definition production. + EnterFunction_definition(c *Function_definitionContext) + + // EnterCreate_function is called when entering the create_function production. + EnterCreate_function(c *Create_functionContext) + + // EnterCreate_managed_account is called when entering the create_managed_account production. + EnterCreate_managed_account(c *Create_managed_accountContext) + + // EnterCreate_masking_policy is called when entering the create_masking_policy production. + EnterCreate_masking_policy(c *Create_masking_policyContext) + + // EnterTag_decl is called when entering the tag_decl production. + EnterTag_decl(c *Tag_declContext) + + // EnterColumn_list_in_parentheses is called when entering the column_list_in_parentheses production. + EnterColumn_list_in_parentheses(c *Column_list_in_parenthesesContext) + + // EnterCreate_materialized_view is called when entering the create_materialized_view production. + EnterCreate_materialized_view(c *Create_materialized_viewContext) + + // EnterCreate_network_policy is called when entering the create_network_policy production. + EnterCreate_network_policy(c *Create_network_policyContext) + + // EnterCloud_provider_params_auto is called when entering the cloud_provider_params_auto production. + EnterCloud_provider_params_auto(c *Cloud_provider_params_autoContext) + + // EnterCloud_provider_params_push is called when entering the cloud_provider_params_push production. + EnterCloud_provider_params_push(c *Cloud_provider_params_pushContext) + + // EnterCreate_notification_integration is called when entering the create_notification_integration production. + EnterCreate_notification_integration(c *Create_notification_integrationContext) + + // EnterCreate_pipe is called when entering the create_pipe production. + EnterCreate_pipe(c *Create_pipeContext) + + // EnterCaller_owner is called when entering the caller_owner production. + EnterCaller_owner(c *Caller_ownerContext) + + // EnterExecuta_as is called when entering the executa_as production. + EnterExecuta_as(c *Executa_asContext) + + // EnterProcedure_definition is called when entering the procedure_definition production. + EnterProcedure_definition(c *Procedure_definitionContext) + + // EnterCreate_procedure is called when entering the create_procedure production. + EnterCreate_procedure(c *Create_procedureContext) + + // EnterCreate_replication_group is called when entering the create_replication_group production. + EnterCreate_replication_group(c *Create_replication_groupContext) + + // EnterCreate_resource_monitor is called when entering the create_resource_monitor production. + EnterCreate_resource_monitor(c *Create_resource_monitorContext) + + // EnterCreate_role is called when entering the create_role production. + EnterCreate_role(c *Create_roleContext) + + // EnterCreate_row_access_policy is called when entering the create_row_access_policy production. + EnterCreate_row_access_policy(c *Create_row_access_policyContext) + + // EnterCreate_schema is called when entering the create_schema production. + EnterCreate_schema(c *Create_schemaContext) + + // EnterCreate_security_integration_external_oauth is called when entering the create_security_integration_external_oauth production. + EnterCreate_security_integration_external_oauth(c *Create_security_integration_external_oauthContext) + + // EnterImplicit_none is called when entering the implicit_none production. + EnterImplicit_none(c *Implicit_noneContext) + + // EnterCreate_security_integration_snowflake_oauth is called when entering the create_security_integration_snowflake_oauth production. + EnterCreate_security_integration_snowflake_oauth(c *Create_security_integration_snowflake_oauthContext) + + // EnterCreate_security_integration_saml2 is called when entering the create_security_integration_saml2 production. + EnterCreate_security_integration_saml2(c *Create_security_integration_saml2Context) + + // EnterCreate_security_integration_scim is called when entering the create_security_integration_scim production. + EnterCreate_security_integration_scim(c *Create_security_integration_scimContext) + + // EnterNetwork_policy is called when entering the network_policy production. + EnterNetwork_policy(c *Network_policyContext) + + // EnterPartner_application is called when entering the partner_application production. + EnterPartner_application(c *Partner_applicationContext) + + // EnterStart_with is called when entering the start_with production. + EnterStart_with(c *Start_withContext) + + // EnterIncrement_by is called when entering the increment_by production. + EnterIncrement_by(c *Increment_byContext) + + // EnterCreate_sequence is called when entering the create_sequence production. + EnterCreate_sequence(c *Create_sequenceContext) + + // EnterCreate_session_policy is called when entering the create_session_policy production. + EnterCreate_session_policy(c *Create_session_policyContext) + + // EnterCreate_share is called when entering the create_share production. + EnterCreate_share(c *Create_shareContext) + + // EnterCharacter is called when entering the character production. + EnterCharacter(c *CharacterContext) + + // EnterFormat_type_options is called when entering the format_type_options production. + EnterFormat_type_options(c *Format_type_optionsContext) + + // EnterCopy_options is called when entering the copy_options production. + EnterCopy_options(c *Copy_optionsContext) + + // EnterInternal_stage_params is called when entering the internal_stage_params production. + EnterInternal_stage_params(c *Internal_stage_paramsContext) + + // EnterStage_type is called when entering the stage_type production. + EnterStage_type(c *Stage_typeContext) + + // EnterStage_master_key is called when entering the stage_master_key production. + EnterStage_master_key(c *Stage_master_keyContext) + + // EnterStage_kms_key is called when entering the stage_kms_key production. + EnterStage_kms_key(c *Stage_kms_keyContext) + + // EnterStage_encryption_opts_aws is called when entering the stage_encryption_opts_aws production. + EnterStage_encryption_opts_aws(c *Stage_encryption_opts_awsContext) + + // EnterAws_token is called when entering the aws_token production. + EnterAws_token(c *Aws_tokenContext) + + // EnterAws_key_id is called when entering the aws_key_id production. + EnterAws_key_id(c *Aws_key_idContext) + + // EnterAws_secret_key is called when entering the aws_secret_key production. + EnterAws_secret_key(c *Aws_secret_keyContext) + + // EnterAws_role is called when entering the aws_role production. + EnterAws_role(c *Aws_roleContext) + + // EnterExternal_stage_params is called when entering the external_stage_params production. + EnterExternal_stage_params(c *External_stage_paramsContext) + + // EnterTrue_false is called when entering the true_false production. + EnterTrue_false(c *True_falseContext) + + // EnterEnable is called when entering the enable production. + EnterEnable(c *EnableContext) + + // EnterRefresh_on_create is called when entering the refresh_on_create production. + EnterRefresh_on_create(c *Refresh_on_createContext) + + // EnterAuto_refresh is called when entering the auto_refresh production. + EnterAuto_refresh(c *Auto_refreshContext) + + // EnterNotification_integration is called when entering the notification_integration production. + EnterNotification_integration(c *Notification_integrationContext) + + // EnterDirectory_table_params is called when entering the directory_table_params production. + EnterDirectory_table_params(c *Directory_table_paramsContext) + + // EnterCreate_stage is called when entering the create_stage production. + EnterCreate_stage(c *Create_stageContext) + + // EnterCloud_provider_params is called when entering the cloud_provider_params production. + EnterCloud_provider_params(c *Cloud_provider_paramsContext) + + // EnterCloud_provider_params2 is called when entering the cloud_provider_params2 production. + EnterCloud_provider_params2(c *Cloud_provider_params2Context) + + // EnterCloud_provider_params3 is called when entering the cloud_provider_params3 production. + EnterCloud_provider_params3(c *Cloud_provider_params3Context) + + // EnterCreate_storage_integration is called when entering the create_storage_integration production. + EnterCreate_storage_integration(c *Create_storage_integrationContext) + + // EnterCopy_grants is called when entering the copy_grants production. + EnterCopy_grants(c *Copy_grantsContext) + + // EnterAppend_only is called when entering the append_only production. + EnterAppend_only(c *Append_onlyContext) + + // EnterInsert_only is called when entering the insert_only production. + EnterInsert_only(c *Insert_onlyContext) + + // EnterShow_initial_rows is called when entering the show_initial_rows production. + EnterShow_initial_rows(c *Show_initial_rowsContext) + + // EnterStream_time is called when entering the stream_time production. + EnterStream_time(c *Stream_timeContext) + + // EnterCreate_stream is called when entering the create_stream production. + EnterCreate_stream(c *Create_streamContext) + + // EnterTemporary is called when entering the temporary production. + EnterTemporary(c *TemporaryContext) + + // EnterTable_type is called when entering the table_type production. + EnterTable_type(c *Table_typeContext) + + // EnterWith_tags is called when entering the with_tags production. + EnterWith_tags(c *With_tagsContext) + + // EnterWith_row_access_policy is called when entering the with_row_access_policy production. + EnterWith_row_access_policy(c *With_row_access_policyContext) + + // EnterCluster_by is called when entering the cluster_by production. + EnterCluster_by(c *Cluster_byContext) + + // EnterChange_tracking is called when entering the change_tracking production. + EnterChange_tracking(c *Change_trackingContext) + + // EnterWith_masking_policy is called when entering the with_masking_policy production. + EnterWith_masking_policy(c *With_masking_policyContext) + + // EnterCollate is called when entering the collate production. + EnterCollate(c *CollateContext) + + // EnterNot_null is called when entering the not_null production. + EnterNot_null(c *Not_nullContext) + + // EnterDefault_value is called when entering the default_value production. + EnterDefault_value(c *Default_valueContext) + + // EnterForeign_key is called when entering the foreign_key production. + EnterForeign_key(c *Foreign_keyContext) + + // EnterOut_of_line_constraint is called when entering the out_of_line_constraint production. + EnterOut_of_line_constraint(c *Out_of_line_constraintContext) + + // EnterFull_col_decl is called when entering the full_col_decl production. + EnterFull_col_decl(c *Full_col_declContext) + + // EnterColumn_decl_item is called when entering the column_decl_item production. + EnterColumn_decl_item(c *Column_decl_itemContext) + + // EnterColumn_decl_item_list is called when entering the column_decl_item_list production. + EnterColumn_decl_item_list(c *Column_decl_item_listContext) + + // EnterCreate_table is called when entering the create_table production. + EnterCreate_table(c *Create_tableContext) + + // EnterCreate_table_as_select is called when entering the create_table_as_select production. + EnterCreate_table_as_select(c *Create_table_as_selectContext) + + // EnterCreate_tag is called when entering the create_tag production. + EnterCreate_tag(c *Create_tagContext) + + // EnterSession_parameter is called when entering the session_parameter production. + EnterSession_parameter(c *Session_parameterContext) + + // EnterSession_parameter_list is called when entering the session_parameter_list production. + EnterSession_parameter_list(c *Session_parameter_listContext) + + // EnterSession_parameter_init_list is called when entering the session_parameter_init_list production. + EnterSession_parameter_init_list(c *Session_parameter_init_listContext) + + // EnterSession_parameter_init is called when entering the session_parameter_init production. + EnterSession_parameter_init(c *Session_parameter_initContext) + + // EnterCreate_task is called when entering the create_task production. + EnterCreate_task(c *Create_taskContext) + + // EnterSql is called when entering the sql production. + EnterSql(c *SqlContext) + + // EnterCall is called when entering the call production. + EnterCall(c *CallContext) + + // EnterCreate_user is called when entering the create_user production. + EnterCreate_user(c *Create_userContext) + + // EnterView_col is called when entering the view_col production. + EnterView_col(c *View_colContext) + + // EnterCreate_view is called when entering the create_view production. + EnterCreate_view(c *Create_viewContext) + + // EnterCreate_warehouse is called when entering the create_warehouse production. + EnterCreate_warehouse(c *Create_warehouseContext) + + // EnterWh_properties is called when entering the wh_properties production. + EnterWh_properties(c *Wh_propertiesContext) + + // EnterWh_params is called when entering the wh_params production. + EnterWh_params(c *Wh_paramsContext) + + // EnterTrigger_definition is called when entering the trigger_definition production. + EnterTrigger_definition(c *Trigger_definitionContext) + + // EnterObject_type_name is called when entering the object_type_name production. + EnterObject_type_name(c *Object_type_nameContext) + + // EnterObject_type_plural is called when entering the object_type_plural production. + EnterObject_type_plural(c *Object_type_pluralContext) + + // EnterDrop_command is called when entering the drop_command production. + EnterDrop_command(c *Drop_commandContext) + + // EnterDrop_object is called when entering the drop_object production. + EnterDrop_object(c *Drop_objectContext) + + // EnterDrop_alert is called when entering the drop_alert production. + EnterDrop_alert(c *Drop_alertContext) + + // EnterDrop_connection is called when entering the drop_connection production. + EnterDrop_connection(c *Drop_connectionContext) + + // EnterDrop_database is called when entering the drop_database production. + EnterDrop_database(c *Drop_databaseContext) + + // EnterDrop_dynamic_table is called when entering the drop_dynamic_table production. + EnterDrop_dynamic_table(c *Drop_dynamic_tableContext) + + // EnterDrop_external_table is called when entering the drop_external_table production. + EnterDrop_external_table(c *Drop_external_tableContext) + + // EnterDrop_failover_group is called when entering the drop_failover_group production. + EnterDrop_failover_group(c *Drop_failover_groupContext) + + // EnterDrop_file_format is called when entering the drop_file_format production. + EnterDrop_file_format(c *Drop_file_formatContext) + + // EnterDrop_function is called when entering the drop_function production. + EnterDrop_function(c *Drop_functionContext) + + // EnterDrop_integration is called when entering the drop_integration production. + EnterDrop_integration(c *Drop_integrationContext) + + // EnterDrop_managed_account is called when entering the drop_managed_account production. + EnterDrop_managed_account(c *Drop_managed_accountContext) + + // EnterDrop_masking_policy is called when entering the drop_masking_policy production. + EnterDrop_masking_policy(c *Drop_masking_policyContext) + + // EnterDrop_materialized_view is called when entering the drop_materialized_view production. + EnterDrop_materialized_view(c *Drop_materialized_viewContext) + + // EnterDrop_network_policy is called when entering the drop_network_policy production. + EnterDrop_network_policy(c *Drop_network_policyContext) + + // EnterDrop_pipe is called when entering the drop_pipe production. + EnterDrop_pipe(c *Drop_pipeContext) + + // EnterDrop_procedure is called when entering the drop_procedure production. + EnterDrop_procedure(c *Drop_procedureContext) + + // EnterDrop_replication_group is called when entering the drop_replication_group production. + EnterDrop_replication_group(c *Drop_replication_groupContext) + + // EnterDrop_resource_monitor is called when entering the drop_resource_monitor production. + EnterDrop_resource_monitor(c *Drop_resource_monitorContext) + + // EnterDrop_role is called when entering the drop_role production. + EnterDrop_role(c *Drop_roleContext) + + // EnterDrop_row_access_policy is called when entering the drop_row_access_policy production. + EnterDrop_row_access_policy(c *Drop_row_access_policyContext) + + // EnterDrop_schema is called when entering the drop_schema production. + EnterDrop_schema(c *Drop_schemaContext) + + // EnterDrop_sequence is called when entering the drop_sequence production. + EnterDrop_sequence(c *Drop_sequenceContext) + + // EnterDrop_session_policy is called when entering the drop_session_policy production. + EnterDrop_session_policy(c *Drop_session_policyContext) + + // EnterDrop_share is called when entering the drop_share production. + EnterDrop_share(c *Drop_shareContext) + + // EnterDrop_stage is called when entering the drop_stage production. + EnterDrop_stage(c *Drop_stageContext) + + // EnterDrop_stream is called when entering the drop_stream production. + EnterDrop_stream(c *Drop_streamContext) + + // EnterDrop_table is called when entering the drop_table production. + EnterDrop_table(c *Drop_tableContext) + + // EnterDrop_tag is called when entering the drop_tag production. + EnterDrop_tag(c *Drop_tagContext) + + // EnterDrop_task is called when entering the drop_task production. + EnterDrop_task(c *Drop_taskContext) + + // EnterDrop_user is called when entering the drop_user production. + EnterDrop_user(c *Drop_userContext) + + // EnterDrop_view is called when entering the drop_view production. + EnterDrop_view(c *Drop_viewContext) + + // EnterDrop_warehouse is called when entering the drop_warehouse production. + EnterDrop_warehouse(c *Drop_warehouseContext) + + // EnterCascade_restrict is called when entering the cascade_restrict production. + EnterCascade_restrict(c *Cascade_restrictContext) + + // EnterArg_types is called when entering the arg_types production. + EnterArg_types(c *Arg_typesContext) + + // EnterUndrop_command is called when entering the undrop_command production. + EnterUndrop_command(c *Undrop_commandContext) + + // EnterUndrop_database is called when entering the undrop_database production. + EnterUndrop_database(c *Undrop_databaseContext) + + // EnterUndrop_dynamic_table is called when entering the undrop_dynamic_table production. + EnterUndrop_dynamic_table(c *Undrop_dynamic_tableContext) + + // EnterUndrop_schema is called when entering the undrop_schema production. + EnterUndrop_schema(c *Undrop_schemaContext) + + // EnterUndrop_table is called when entering the undrop_table production. + EnterUndrop_table(c *Undrop_tableContext) + + // EnterUndrop_tag is called when entering the undrop_tag production. + EnterUndrop_tag(c *Undrop_tagContext) + + // EnterUse_command is called when entering the use_command production. + EnterUse_command(c *Use_commandContext) + + // EnterUse_database is called when entering the use_database production. + EnterUse_database(c *Use_databaseContext) + + // EnterUse_role is called when entering the use_role production. + EnterUse_role(c *Use_roleContext) + + // EnterUse_schema is called when entering the use_schema production. + EnterUse_schema(c *Use_schemaContext) + + // EnterUse_secondary_roles is called when entering the use_secondary_roles production. + EnterUse_secondary_roles(c *Use_secondary_rolesContext) + + // EnterUse_warehouse is called when entering the use_warehouse production. + EnterUse_warehouse(c *Use_warehouseContext) + + // EnterComment_clause is called when entering the comment_clause production. + EnterComment_clause(c *Comment_clauseContext) + + // EnterIf_suspended is called when entering the if_suspended production. + EnterIf_suspended(c *If_suspendedContext) + + // EnterIf_exists is called when entering the if_exists production. + EnterIf_exists(c *If_existsContext) + + // EnterIf_not_exists is called when entering the if_not_exists production. + EnterIf_not_exists(c *If_not_existsContext) + + // EnterOr_replace is called when entering the or_replace production. + EnterOr_replace(c *Or_replaceContext) + + // EnterDescribe is called when entering the describe production. + EnterDescribe(c *DescribeContext) + + // EnterDescribe_command is called when entering the describe_command production. + EnterDescribe_command(c *Describe_commandContext) + + // EnterDescribe_alert is called when entering the describe_alert production. + EnterDescribe_alert(c *Describe_alertContext) + + // EnterDescribe_database is called when entering the describe_database production. + EnterDescribe_database(c *Describe_databaseContext) + + // EnterDescribe_dynamic_table is called when entering the describe_dynamic_table production. + EnterDescribe_dynamic_table(c *Describe_dynamic_tableContext) + + // EnterDescribe_external_table is called when entering the describe_external_table production. + EnterDescribe_external_table(c *Describe_external_tableContext) + + // EnterDescribe_file_format is called when entering the describe_file_format production. + EnterDescribe_file_format(c *Describe_file_formatContext) + + // EnterDescribe_function is called when entering the describe_function production. + EnterDescribe_function(c *Describe_functionContext) + + // EnterDescribe_integration is called when entering the describe_integration production. + EnterDescribe_integration(c *Describe_integrationContext) + + // EnterDescribe_masking_policy is called when entering the describe_masking_policy production. + EnterDescribe_masking_policy(c *Describe_masking_policyContext) + + // EnterDescribe_materialized_view is called when entering the describe_materialized_view production. + EnterDescribe_materialized_view(c *Describe_materialized_viewContext) + + // EnterDescribe_network_policy is called when entering the describe_network_policy production. + EnterDescribe_network_policy(c *Describe_network_policyContext) + + // EnterDescribe_pipe is called when entering the describe_pipe production. + EnterDescribe_pipe(c *Describe_pipeContext) + + // EnterDescribe_procedure is called when entering the describe_procedure production. + EnterDescribe_procedure(c *Describe_procedureContext) + + // EnterDescribe_result is called when entering the describe_result production. + EnterDescribe_result(c *Describe_resultContext) + + // EnterDescribe_row_access_policy is called when entering the describe_row_access_policy production. + EnterDescribe_row_access_policy(c *Describe_row_access_policyContext) + + // EnterDescribe_schema is called when entering the describe_schema production. + EnterDescribe_schema(c *Describe_schemaContext) + + // EnterDescribe_search_optimization is called when entering the describe_search_optimization production. + EnterDescribe_search_optimization(c *Describe_search_optimizationContext) + + // EnterDescribe_sequence is called when entering the describe_sequence production. + EnterDescribe_sequence(c *Describe_sequenceContext) + + // EnterDescribe_session_policy is called when entering the describe_session_policy production. + EnterDescribe_session_policy(c *Describe_session_policyContext) + + // EnterDescribe_share is called when entering the describe_share production. + EnterDescribe_share(c *Describe_shareContext) + + // EnterDescribe_stage is called when entering the describe_stage production. + EnterDescribe_stage(c *Describe_stageContext) + + // EnterDescribe_stream is called when entering the describe_stream production. + EnterDescribe_stream(c *Describe_streamContext) + + // EnterDescribe_table is called when entering the describe_table production. + EnterDescribe_table(c *Describe_tableContext) + + // EnterDescribe_task is called when entering the describe_task production. + EnterDescribe_task(c *Describe_taskContext) + + // EnterDescribe_transaction is called when entering the describe_transaction production. + EnterDescribe_transaction(c *Describe_transactionContext) + + // EnterDescribe_user is called when entering the describe_user production. + EnterDescribe_user(c *Describe_userContext) + + // EnterDescribe_view is called when entering the describe_view production. + EnterDescribe_view(c *Describe_viewContext) + + // EnterDescribe_warehouse is called when entering the describe_warehouse production. + EnterDescribe_warehouse(c *Describe_warehouseContext) + + // EnterShow_command is called when entering the show_command production. + EnterShow_command(c *Show_commandContext) + + // EnterShow_alerts is called when entering the show_alerts production. + EnterShow_alerts(c *Show_alertsContext) + + // EnterShow_columns is called when entering the show_columns production. + EnterShow_columns(c *Show_columnsContext) + + // EnterShow_connections is called when entering the show_connections production. + EnterShow_connections(c *Show_connectionsContext) + + // EnterStarts_with is called when entering the starts_with production. + EnterStarts_with(c *Starts_withContext) + + // EnterLimit_rows is called when entering the limit_rows production. + EnterLimit_rows(c *Limit_rowsContext) + + // EnterShow_databases is called when entering the show_databases production. + EnterShow_databases(c *Show_databasesContext) + + // EnterShow_databases_in_failover_group is called when entering the show_databases_in_failover_group production. + EnterShow_databases_in_failover_group(c *Show_databases_in_failover_groupContext) + + // EnterShow_databases_in_replication_group is called when entering the show_databases_in_replication_group production. + EnterShow_databases_in_replication_group(c *Show_databases_in_replication_groupContext) + + // EnterShow_delegated_authorizations is called when entering the show_delegated_authorizations production. + EnterShow_delegated_authorizations(c *Show_delegated_authorizationsContext) + + // EnterShow_external_functions is called when entering the show_external_functions production. + EnterShow_external_functions(c *Show_external_functionsContext) + + // EnterShow_dynamic_tables is called when entering the show_dynamic_tables production. + EnterShow_dynamic_tables(c *Show_dynamic_tablesContext) + + // EnterShow_external_tables is called when entering the show_external_tables production. + EnterShow_external_tables(c *Show_external_tablesContext) + + // EnterShow_failover_groups is called when entering the show_failover_groups production. + EnterShow_failover_groups(c *Show_failover_groupsContext) + + // EnterShow_file_formats is called when entering the show_file_formats production. + EnterShow_file_formats(c *Show_file_formatsContext) + + // EnterShow_functions is called when entering the show_functions production. + EnterShow_functions(c *Show_functionsContext) + + // EnterShow_global_accounts is called when entering the show_global_accounts production. + EnterShow_global_accounts(c *Show_global_accountsContext) + + // EnterShow_grants is called when entering the show_grants production. + EnterShow_grants(c *Show_grantsContext) + + // EnterShow_grants_opts is called when entering the show_grants_opts production. + EnterShow_grants_opts(c *Show_grants_optsContext) + + // EnterShow_integrations is called when entering the show_integrations production. + EnterShow_integrations(c *Show_integrationsContext) + + // EnterShow_locks is called when entering the show_locks production. + EnterShow_locks(c *Show_locksContext) + + // EnterShow_managed_accounts is called when entering the show_managed_accounts production. + EnterShow_managed_accounts(c *Show_managed_accountsContext) + + // EnterShow_masking_policies is called when entering the show_masking_policies production. + EnterShow_masking_policies(c *Show_masking_policiesContext) + + // EnterIn_obj is called when entering the in_obj production. + EnterIn_obj(c *In_objContext) + + // EnterIn_obj_2 is called when entering the in_obj_2 production. + EnterIn_obj_2(c *In_obj_2Context) + + // EnterShow_materialized_views is called when entering the show_materialized_views production. + EnterShow_materialized_views(c *Show_materialized_viewsContext) + + // EnterShow_network_policies is called when entering the show_network_policies production. + EnterShow_network_policies(c *Show_network_policiesContext) + + // EnterShow_objects is called when entering the show_objects production. + EnterShow_objects(c *Show_objectsContext) + + // EnterShow_organization_accounts is called when entering the show_organization_accounts production. + EnterShow_organization_accounts(c *Show_organization_accountsContext) + + // EnterIn_for is called when entering the in_for production. + EnterIn_for(c *In_forContext) + + // EnterShow_parameters is called when entering the show_parameters production. + EnterShow_parameters(c *Show_parametersContext) + + // EnterShow_pipes is called when entering the show_pipes production. + EnterShow_pipes(c *Show_pipesContext) + + // EnterShow_primary_keys is called when entering the show_primary_keys production. + EnterShow_primary_keys(c *Show_primary_keysContext) + + // EnterShow_procedures is called when entering the show_procedures production. + EnterShow_procedures(c *Show_proceduresContext) + + // EnterShow_regions is called when entering the show_regions production. + EnterShow_regions(c *Show_regionsContext) + + // EnterShow_replication_accounts is called when entering the show_replication_accounts production. + EnterShow_replication_accounts(c *Show_replication_accountsContext) + + // EnterShow_replication_databases is called when entering the show_replication_databases production. + EnterShow_replication_databases(c *Show_replication_databasesContext) + + // EnterShow_replication_groups is called when entering the show_replication_groups production. + EnterShow_replication_groups(c *Show_replication_groupsContext) + + // EnterShow_resource_monitors is called when entering the show_resource_monitors production. + EnterShow_resource_monitors(c *Show_resource_monitorsContext) + + // EnterShow_roles is called when entering the show_roles production. + EnterShow_roles(c *Show_rolesContext) + + // EnterShow_row_access_policies is called when entering the show_row_access_policies production. + EnterShow_row_access_policies(c *Show_row_access_policiesContext) + + // EnterShow_schemas is called when entering the show_schemas production. + EnterShow_schemas(c *Show_schemasContext) + + // EnterShow_sequences is called when entering the show_sequences production. + EnterShow_sequences(c *Show_sequencesContext) + + // EnterShow_session_policies is called when entering the show_session_policies production. + EnterShow_session_policies(c *Show_session_policiesContext) + + // EnterShow_shares is called when entering the show_shares production. + EnterShow_shares(c *Show_sharesContext) + + // EnterShow_shares_in_failover_group is called when entering the show_shares_in_failover_group production. + EnterShow_shares_in_failover_group(c *Show_shares_in_failover_groupContext) + + // EnterShow_shares_in_replication_group is called when entering the show_shares_in_replication_group production. + EnterShow_shares_in_replication_group(c *Show_shares_in_replication_groupContext) + + // EnterShow_stages is called when entering the show_stages production. + EnterShow_stages(c *Show_stagesContext) + + // EnterShow_streams is called when entering the show_streams production. + EnterShow_streams(c *Show_streamsContext) + + // EnterShow_tables is called when entering the show_tables production. + EnterShow_tables(c *Show_tablesContext) + + // EnterShow_tags is called when entering the show_tags production. + EnterShow_tags(c *Show_tagsContext) + + // EnterShow_tasks is called when entering the show_tasks production. + EnterShow_tasks(c *Show_tasksContext) + + // EnterShow_transactions is called when entering the show_transactions production. + EnterShow_transactions(c *Show_transactionsContext) + + // EnterShow_user_functions is called when entering the show_user_functions production. + EnterShow_user_functions(c *Show_user_functionsContext) + + // EnterShow_users is called when entering the show_users production. + EnterShow_users(c *Show_usersContext) + + // EnterShow_variables is called when entering the show_variables production. + EnterShow_variables(c *Show_variablesContext) + + // EnterShow_views is called when entering the show_views production. + EnterShow_views(c *Show_viewsContext) + + // EnterShow_warehouses is called when entering the show_warehouses production. + EnterShow_warehouses(c *Show_warehousesContext) + + // EnterLike_pattern is called when entering the like_pattern production. + EnterLike_pattern(c *Like_patternContext) + + // EnterAccount_identifier is called when entering the account_identifier production. + EnterAccount_identifier(c *Account_identifierContext) + + // EnterSchema_name is called when entering the schema_name production. + EnterSchema_name(c *Schema_nameContext) + + // EnterObject_type is called when entering the object_type production. + EnterObject_type(c *Object_typeContext) + + // EnterObject_type_list is called when entering the object_type_list production. + EnterObject_type_list(c *Object_type_listContext) + + // EnterTag_value is called when entering the tag_value production. + EnterTag_value(c *Tag_valueContext) + + // EnterArg_data_type is called when entering the arg_data_type production. + EnterArg_data_type(c *Arg_data_typeContext) + + // EnterArg_name is called when entering the arg_name production. + EnterArg_name(c *Arg_nameContext) + + // EnterParam_name is called when entering the param_name production. + EnterParam_name(c *Param_nameContext) + + // EnterRegion_group_id is called when entering the region_group_id production. + EnterRegion_group_id(c *Region_group_idContext) + + // EnterSnowflake_region_id is called when entering the snowflake_region_id production. + EnterSnowflake_region_id(c *Snowflake_region_idContext) + + // EnterString is called when entering the string production. + EnterString(c *StringContext) + + // EnterString_list is called when entering the string_list production. + EnterString_list(c *String_listContext) + + // EnterId_ is called when entering the id_ production. + EnterId_(c *Id_Context) + + // EnterKeyword is called when entering the keyword production. + EnterKeyword(c *KeywordContext) + + // EnterNon_reserved_words is called when entering the non_reserved_words production. + EnterNon_reserved_words(c *Non_reserved_wordsContext) + + // EnterBuiltin_function is called when entering the builtin_function production. + EnterBuiltin_function(c *Builtin_functionContext) + + // EnterList_operator is called when entering the list_operator production. + EnterList_operator(c *List_operatorContext) + + // EnterBinary_builtin_function is called when entering the binary_builtin_function production. + EnterBinary_builtin_function(c *Binary_builtin_functionContext) + + // EnterBinary_or_ternary_builtin_function is called when entering the binary_or_ternary_builtin_function production. + EnterBinary_or_ternary_builtin_function(c *Binary_or_ternary_builtin_functionContext) + + // EnterTernary_builtin_function is called when entering the ternary_builtin_function production. + EnterTernary_builtin_function(c *Ternary_builtin_functionContext) + + // EnterPattern is called when entering the pattern production. + EnterPattern(c *PatternContext) + + // EnterColumn_name is called when entering the column_name production. + EnterColumn_name(c *Column_nameContext) + + // EnterColumn_list is called when entering the column_list production. + EnterColumn_list(c *Column_listContext) + + // EnterObject_name is called when entering the object_name production. + EnterObject_name(c *Object_nameContext) + + // EnterNum is called when entering the num production. + EnterNum(c *NumContext) + + // EnterExpr_list is called when entering the expr_list production. + EnterExpr_list(c *Expr_listContext) + + // EnterExpr_list_sorted is called when entering the expr_list_sorted production. + EnterExpr_list_sorted(c *Expr_list_sortedContext) + + // EnterExpr is called when entering the expr production. + EnterExpr(c *ExprContext) + + // EnterIff_expr is called when entering the iff_expr production. + EnterIff_expr(c *Iff_exprContext) + + // EnterTrim_expression is called when entering the trim_expression production. + EnterTrim_expression(c *Trim_expressionContext) + + // EnterTry_cast_expr is called when entering the try_cast_expr production. + EnterTry_cast_expr(c *Try_cast_exprContext) + + // EnterJson_literal is called when entering the json_literal production. + EnterJson_literal(c *Json_literalContext) + + // EnterKv_pair is called when entering the kv_pair production. + EnterKv_pair(c *Kv_pairContext) + + // EnterValue is called when entering the value production. + EnterValue(c *ValueContext) + + // EnterArr_literal is called when entering the arr_literal production. + EnterArr_literal(c *Arr_literalContext) + + // EnterData_type is called when entering the data_type production. + EnterData_type(c *Data_typeContext) + + // EnterPrimitive_expression is called when entering the primitive_expression production. + EnterPrimitive_expression(c *Primitive_expressionContext) + + // EnterOrder_by_expr is called when entering the order_by_expr production. + EnterOrder_by_expr(c *Order_by_exprContext) + + // EnterAsc_desc is called when entering the asc_desc production. + EnterAsc_desc(c *Asc_descContext) + + // EnterOver_clause is called when entering the over_clause production. + EnterOver_clause(c *Over_clauseContext) + + // EnterFunction_call is called when entering the function_call production. + EnterFunction_call(c *Function_callContext) + + // EnterRanking_windowed_function is called when entering the ranking_windowed_function production. + EnterRanking_windowed_function(c *Ranking_windowed_functionContext) + + // EnterAggregate_function is called when entering the aggregate_function production. + EnterAggregate_function(c *Aggregate_functionContext) + + // EnterLiteral is called when entering the literal production. + EnterLiteral(c *LiteralContext) + + // EnterSign is called when entering the sign production. + EnterSign(c *SignContext) + + // EnterFull_column_name is called when entering the full_column_name production. + EnterFull_column_name(c *Full_column_nameContext) + + // EnterBracket_expression is called when entering the bracket_expression production. + EnterBracket_expression(c *Bracket_expressionContext) + + // EnterCase_expression is called when entering the case_expression production. + EnterCase_expression(c *Case_expressionContext) + + // EnterSwitch_search_condition_section is called when entering the switch_search_condition_section production. + EnterSwitch_search_condition_section(c *Switch_search_condition_sectionContext) + + // EnterSwitch_section is called when entering the switch_section production. + EnterSwitch_section(c *Switch_sectionContext) + + // EnterQuery_statement is called when entering the query_statement production. + EnterQuery_statement(c *Query_statementContext) + + // EnterWith_expression is called when entering the with_expression production. + EnterWith_expression(c *With_expressionContext) + + // EnterCommon_table_expression is called when entering the common_table_expression production. + EnterCommon_table_expression(c *Common_table_expressionContext) + + // EnterAnchor_clause is called when entering the anchor_clause production. + EnterAnchor_clause(c *Anchor_clauseContext) + + // EnterRecursive_clause is called when entering the recursive_clause production. + EnterRecursive_clause(c *Recursive_clauseContext) + + // EnterSelect_statement is called when entering the select_statement production. + EnterSelect_statement(c *Select_statementContext) + + // EnterSet_operators is called when entering the set_operators production. + EnterSet_operators(c *Set_operatorsContext) + + // EnterSelect_optional_clauses is called when entering the select_optional_clauses production. + EnterSelect_optional_clauses(c *Select_optional_clausesContext) + + // EnterSelect_clause is called when entering the select_clause production. + EnterSelect_clause(c *Select_clauseContext) + + // EnterSelect_top_clause is called when entering the select_top_clause production. + EnterSelect_top_clause(c *Select_top_clauseContext) + + // EnterSelect_list_no_top is called when entering the select_list_no_top production. + EnterSelect_list_no_top(c *Select_list_no_topContext) + + // EnterSelect_list_top is called when entering the select_list_top production. + EnterSelect_list_top(c *Select_list_topContext) + + // EnterSelect_list is called when entering the select_list production. + EnterSelect_list(c *Select_listContext) + + // EnterSelect_list_elem is called when entering the select_list_elem production. + EnterSelect_list_elem(c *Select_list_elemContext) + + // EnterColumn_elem is called when entering the column_elem production. + EnterColumn_elem(c *Column_elemContext) + + // EnterAs_alias is called when entering the as_alias production. + EnterAs_alias(c *As_aliasContext) + + // EnterExpression_elem is called when entering the expression_elem production. + EnterExpression_elem(c *Expression_elemContext) + + // EnterColumn_position is called when entering the column_position production. + EnterColumn_position(c *Column_positionContext) + + // EnterAll_distinct is called when entering the all_distinct production. + EnterAll_distinct(c *All_distinctContext) + + // EnterTop_clause is called when entering the top_clause production. + EnterTop_clause(c *Top_clauseContext) + + // EnterInto_clause is called when entering the into_clause production. + EnterInto_clause(c *Into_clauseContext) + + // EnterVar_list is called when entering the var_list production. + EnterVar_list(c *Var_listContext) + + // EnterVar is called when entering the var production. + EnterVar(c *VarContext) + + // EnterFrom_clause is called when entering the from_clause production. + EnterFrom_clause(c *From_clauseContext) + + // EnterTable_sources is called when entering the table_sources production. + EnterTable_sources(c *Table_sourcesContext) + + // EnterTable_source is called when entering the table_source production. + EnterTable_source(c *Table_sourceContext) + + // EnterTable_source_item_joined is called when entering the table_source_item_joined production. + EnterTable_source_item_joined(c *Table_source_item_joinedContext) + + // EnterObject_ref is called when entering the object_ref production. + EnterObject_ref(c *Object_refContext) + + // EnterFlatten_table_option is called when entering the flatten_table_option production. + EnterFlatten_table_option(c *Flatten_table_optionContext) + + // EnterFlatten_table is called when entering the flatten_table production. + EnterFlatten_table(c *Flatten_tableContext) + + // EnterPrior_list is called when entering the prior_list production. + EnterPrior_list(c *Prior_listContext) + + // EnterPrior_item is called when entering the prior_item production. + EnterPrior_item(c *Prior_itemContext) + + // EnterOuter_join is called when entering the outer_join production. + EnterOuter_join(c *Outer_joinContext) + + // EnterJoin_type is called when entering the join_type production. + EnterJoin_type(c *Join_typeContext) + + // EnterJoin_clause is called when entering the join_clause production. + EnterJoin_clause(c *Join_clauseContext) + + // EnterAt_before is called when entering the at_before production. + EnterAt_before(c *At_beforeContext) + + // EnterEnd is called when entering the end production. + EnterEnd(c *EndContext) + + // EnterChanges is called when entering the changes production. + EnterChanges(c *ChangesContext) + + // EnterDefault_append_only is called when entering the default_append_only production. + EnterDefault_append_only(c *Default_append_onlyContext) + + // EnterPartition_by is called when entering the partition_by production. + EnterPartition_by(c *Partition_byContext) + + // EnterAlias is called when entering the alias production. + EnterAlias(c *AliasContext) + + // EnterExpr_alias_list is called when entering the expr_alias_list production. + EnterExpr_alias_list(c *Expr_alias_listContext) + + // EnterMeasures is called when entering the measures production. + EnterMeasures(c *MeasuresContext) + + // EnterMatch_opts is called when entering the match_opts production. + EnterMatch_opts(c *Match_optsContext) + + // EnterRow_match is called when entering the row_match production. + EnterRow_match(c *Row_matchContext) + + // EnterFirst_last is called when entering the first_last production. + EnterFirst_last(c *First_lastContext) + + // EnterSymbol is called when entering the symbol production. + EnterSymbol(c *SymbolContext) + + // EnterAfter_match is called when entering the after_match production. + EnterAfter_match(c *After_matchContext) + + // EnterSymbol_list is called when entering the symbol_list production. + EnterSymbol_list(c *Symbol_listContext) + + // EnterDefine is called when entering the define production. + EnterDefine(c *DefineContext) + + // EnterMatch_recognize is called when entering the match_recognize production. + EnterMatch_recognize(c *Match_recognizeContext) + + // EnterPivot_unpivot is called when entering the pivot_unpivot production. + EnterPivot_unpivot(c *Pivot_unpivotContext) + + // EnterColumn_alias_list_in_brackets is called when entering the column_alias_list_in_brackets production. + EnterColumn_alias_list_in_brackets(c *Column_alias_list_in_bracketsContext) + + // EnterExpr_list_in_parentheses is called when entering the expr_list_in_parentheses production. + EnterExpr_list_in_parentheses(c *Expr_list_in_parenthesesContext) + + // EnterValues is called when entering the values production. + EnterValues(c *ValuesContext) + + // EnterSample_method is called when entering the sample_method production. + EnterSample_method(c *Sample_methodContext) + + // EnterRepeatable_seed is called when entering the repeatable_seed production. + EnterRepeatable_seed(c *Repeatable_seedContext) + + // EnterSample_opts is called when entering the sample_opts production. + EnterSample_opts(c *Sample_optsContext) + + // EnterSample is called when entering the sample production. + EnterSample(c *SampleContext) + + // EnterSearch_condition is called when entering the search_condition production. + EnterSearch_condition(c *Search_conditionContext) + + // EnterComparison_operator is called when entering the comparison_operator production. + EnterComparison_operator(c *Comparison_operatorContext) + + // EnterNull_not_null is called when entering the null_not_null production. + EnterNull_not_null(c *Null_not_nullContext) + + // EnterSubquery is called when entering the subquery production. + EnterSubquery(c *SubqueryContext) + + // EnterPredicate is called when entering the predicate production. + EnterPredicate(c *PredicateContext) + + // EnterWhere_clause is called when entering the where_clause production. + EnterWhere_clause(c *Where_clauseContext) + + // EnterGroup_item is called when entering the group_item production. + EnterGroup_item(c *Group_itemContext) + + // EnterGroup_by_clause is called when entering the group_by_clause production. + EnterGroup_by_clause(c *Group_by_clauseContext) + + // EnterHaving_clause is called when entering the having_clause production. + EnterHaving_clause(c *Having_clauseContext) + + // EnterQualify_clause is called when entering the qualify_clause production. + EnterQualify_clause(c *Qualify_clauseContext) + + // EnterOrder_item is called when entering the order_item production. + EnterOrder_item(c *Order_itemContext) + + // EnterOrder_by_clause is called when entering the order_by_clause production. + EnterOrder_by_clause(c *Order_by_clauseContext) + + // EnterRow_rows is called when entering the row_rows production. + EnterRow_rows(c *Row_rowsContext) + + // EnterFirst_next is called when entering the first_next production. + EnterFirst_next(c *First_nextContext) + + // EnterLimit_clause is called when entering the limit_clause production. + EnterLimit_clause(c *Limit_clauseContext) + + // EnterSupplement_non_reserved_words is called when entering the supplement_non_reserved_words production. + EnterSupplement_non_reserved_words(c *Supplement_non_reserved_wordsContext) + + // ExitSnowflake_file is called when exiting the snowflake_file production. + ExitSnowflake_file(c *Snowflake_fileContext) + + // ExitBatch is called when exiting the batch production. + ExitBatch(c *BatchContext) + + // ExitSql_command is called when exiting the sql_command production. + ExitSql_command(c *Sql_commandContext) + + // ExitDdl_command is called when exiting the ddl_command production. + ExitDdl_command(c *Ddl_commandContext) + + // ExitDml_command is called when exiting the dml_command production. + ExitDml_command(c *Dml_commandContext) + + // ExitInsert_statement is called when exiting the insert_statement production. + ExitInsert_statement(c *Insert_statementContext) + + // ExitInsert_multi_table_statement is called when exiting the insert_multi_table_statement production. + ExitInsert_multi_table_statement(c *Insert_multi_table_statementContext) + + // ExitInto_clause2 is called when exiting the into_clause2 production. + ExitInto_clause2(c *Into_clause2Context) + + // ExitValues_list is called when exiting the values_list production. + ExitValues_list(c *Values_listContext) + + // ExitValue_item is called when exiting the value_item production. + ExitValue_item(c *Value_itemContext) + + // ExitMerge_statement is called when exiting the merge_statement production. + ExitMerge_statement(c *Merge_statementContext) + + // ExitMerge_matches is called when exiting the merge_matches production. + ExitMerge_matches(c *Merge_matchesContext) + + // ExitMerge_update_delete is called when exiting the merge_update_delete production. + ExitMerge_update_delete(c *Merge_update_deleteContext) + + // ExitMerge_insert is called when exiting the merge_insert production. + ExitMerge_insert(c *Merge_insertContext) + + // ExitUpdate_statement is called when exiting the update_statement production. + ExitUpdate_statement(c *Update_statementContext) + + // ExitTable_or_query is called when exiting the table_or_query production. + ExitTable_or_query(c *Table_or_queryContext) + + // ExitDelete_statement is called when exiting the delete_statement production. + ExitDelete_statement(c *Delete_statementContext) + + // ExitValues_builder is called when exiting the values_builder production. + ExitValues_builder(c *Values_builderContext) + + // ExitOther_command is called when exiting the other_command production. + ExitOther_command(c *Other_commandContext) + + // ExitCopy_into_table is called when exiting the copy_into_table production. + ExitCopy_into_table(c *Copy_into_tableContext) + + // ExitExternal_location is called when exiting the external_location production. + ExitExternal_location(c *External_locationContext) + + // ExitFiles is called when exiting the files production. + ExitFiles(c *FilesContext) + + // ExitFile_format is called when exiting the file_format production. + ExitFile_format(c *File_formatContext) + + // ExitFormat_name is called when exiting the format_name production. + ExitFormat_name(c *Format_nameContext) + + // ExitFormat_type is called when exiting the format_type production. + ExitFormat_type(c *Format_typeContext) + + // ExitStage_file_format is called when exiting the stage_file_format production. + ExitStage_file_format(c *Stage_file_formatContext) + + // ExitCopy_into_location is called when exiting the copy_into_location production. + ExitCopy_into_location(c *Copy_into_locationContext) + + // ExitComment is called when exiting the comment production. + ExitComment(c *CommentContext) + + // ExitCommit is called when exiting the commit production. + ExitCommit(c *CommitContext) + + // ExitExecute_immediate is called when exiting the execute_immediate production. + ExitExecute_immediate(c *Execute_immediateContext) + + // ExitExecute_task is called when exiting the execute_task production. + ExitExecute_task(c *Execute_taskContext) + + // ExitExplain is called when exiting the explain production. + ExitExplain(c *ExplainContext) + + // ExitParallel is called when exiting the parallel production. + ExitParallel(c *ParallelContext) + + // ExitGet_dml is called when exiting the get_dml production. + ExitGet_dml(c *Get_dmlContext) + + // ExitGrant_ownership is called when exiting the grant_ownership production. + ExitGrant_ownership(c *Grant_ownershipContext) + + // ExitGrant_to_role is called when exiting the grant_to_role production. + ExitGrant_to_role(c *Grant_to_roleContext) + + // ExitGlobal_privileges is called when exiting the global_privileges production. + ExitGlobal_privileges(c *Global_privilegesContext) + + // ExitGlobal_privilege is called when exiting the global_privilege production. + ExitGlobal_privilege(c *Global_privilegeContext) + + // ExitAccount_object_privileges is called when exiting the account_object_privileges production. + ExitAccount_object_privileges(c *Account_object_privilegesContext) + + // ExitAccount_object_privilege is called when exiting the account_object_privilege production. + ExitAccount_object_privilege(c *Account_object_privilegeContext) + + // ExitSchema_privileges is called when exiting the schema_privileges production. + ExitSchema_privileges(c *Schema_privilegesContext) + + // ExitSchema_privilege is called when exiting the schema_privilege production. + ExitSchema_privilege(c *Schema_privilegeContext) + + // ExitSchema_object_privileges is called when exiting the schema_object_privileges production. + ExitSchema_object_privileges(c *Schema_object_privilegesContext) + + // ExitSchema_object_privilege is called when exiting the schema_object_privilege production. + ExitSchema_object_privilege(c *Schema_object_privilegeContext) + + // ExitGrant_to_share is called when exiting the grant_to_share production. + ExitGrant_to_share(c *Grant_to_shareContext) + + // ExitObject_privilege is called when exiting the object_privilege production. + ExitObject_privilege(c *Object_privilegeContext) + + // ExitGrant_role is called when exiting the grant_role production. + ExitGrant_role(c *Grant_roleContext) + + // ExitRole_name is called when exiting the role_name production. + ExitRole_name(c *Role_nameContext) + + // ExitSystem_defined_role is called when exiting the system_defined_role production. + ExitSystem_defined_role(c *System_defined_roleContext) + + // ExitList is called when exiting the list production. + ExitList(c *ListContext) + + // ExitInternal_stage is called when exiting the internal_stage production. + ExitInternal_stage(c *Internal_stageContext) + + // ExitExternal_stage is called when exiting the external_stage production. + ExitExternal_stage(c *External_stageContext) + + // ExitPut is called when exiting the put production. + ExitPut(c *PutContext) + + // ExitRemove is called when exiting the remove production. + ExitRemove(c *RemoveContext) + + // ExitRevoke_from_role is called when exiting the revoke_from_role production. + ExitRevoke_from_role(c *Revoke_from_roleContext) + + // ExitRevoke_from_share is called when exiting the revoke_from_share production. + ExitRevoke_from_share(c *Revoke_from_shareContext) + + // ExitRevoke_role is called when exiting the revoke_role production. + ExitRevoke_role(c *Revoke_roleContext) + + // ExitRollback is called when exiting the rollback production. + ExitRollback(c *RollbackContext) + + // ExitSet is called when exiting the set production. + ExitSet(c *SetContext) + + // ExitTruncate_materialized_view is called when exiting the truncate_materialized_view production. + ExitTruncate_materialized_view(c *Truncate_materialized_viewContext) + + // ExitTruncate_table is called when exiting the truncate_table production. + ExitTruncate_table(c *Truncate_tableContext) + + // ExitUnset is called when exiting the unset production. + ExitUnset(c *UnsetContext) + + // ExitAlter_command is called when exiting the alter_command production. + ExitAlter_command(c *Alter_commandContext) + + // ExitAccount_params is called when exiting the account_params production. + ExitAccount_params(c *Account_paramsContext) + + // ExitObject_params is called when exiting the object_params production. + ExitObject_params(c *Object_paramsContext) + + // ExitDefault_ddl_collation is called when exiting the default_ddl_collation production. + ExitDefault_ddl_collation(c *Default_ddl_collationContext) + + // ExitObject_properties is called when exiting the object_properties production. + ExitObject_properties(c *Object_propertiesContext) + + // ExitSession_params is called when exiting the session_params production. + ExitSession_params(c *Session_paramsContext) + + // ExitAlter_account is called when exiting the alter_account production. + ExitAlter_account(c *Alter_accountContext) + + // ExitEnabled_true_false is called when exiting the enabled_true_false production. + ExitEnabled_true_false(c *Enabled_true_falseContext) + + // ExitAlter_alert is called when exiting the alter_alert production. + ExitAlter_alert(c *Alter_alertContext) + + // ExitResume_suspend is called when exiting the resume_suspend production. + ExitResume_suspend(c *Resume_suspendContext) + + // ExitAlert_set_clause is called when exiting the alert_set_clause production. + ExitAlert_set_clause(c *Alert_set_clauseContext) + + // ExitAlert_unset_clause is called when exiting the alert_unset_clause production. + ExitAlert_unset_clause(c *Alert_unset_clauseContext) + + // ExitAlter_api_integration is called when exiting the alter_api_integration production. + ExitAlter_api_integration(c *Alter_api_integrationContext) + + // ExitApi_integration_property is called when exiting the api_integration_property production. + ExitApi_integration_property(c *Api_integration_propertyContext) + + // ExitAlter_connection is called when exiting the alter_connection production. + ExitAlter_connection(c *Alter_connectionContext) + + // ExitAlter_database is called when exiting the alter_database production. + ExitAlter_database(c *Alter_databaseContext) + + // ExitDatabase_property is called when exiting the database_property production. + ExitDatabase_property(c *Database_propertyContext) + + // ExitAccount_id_list is called when exiting the account_id_list production. + ExitAccount_id_list(c *Account_id_listContext) + + // ExitAlter_dynamic_table is called when exiting the alter_dynamic_table production. + ExitAlter_dynamic_table(c *Alter_dynamic_tableContext) + + // ExitAlter_external_table is called when exiting the alter_external_table production. + ExitAlter_external_table(c *Alter_external_tableContext) + + // ExitIgnore_edition_check is called when exiting the ignore_edition_check production. + ExitIgnore_edition_check(c *Ignore_edition_checkContext) + + // ExitReplication_schedule is called when exiting the replication_schedule production. + ExitReplication_schedule(c *Replication_scheduleContext) + + // ExitDb_name_list is called when exiting the db_name_list production. + ExitDb_name_list(c *Db_name_listContext) + + // ExitShare_name_list is called when exiting the share_name_list production. + ExitShare_name_list(c *Share_name_listContext) + + // ExitFull_acct_list is called when exiting the full_acct_list production. + ExitFull_acct_list(c *Full_acct_listContext) + + // ExitAlter_failover_group is called when exiting the alter_failover_group production. + ExitAlter_failover_group(c *Alter_failover_groupContext) + + // ExitAlter_file_format is called when exiting the alter_file_format production. + ExitAlter_file_format(c *Alter_file_formatContext) + + // ExitAlter_function is called when exiting the alter_function production. + ExitAlter_function(c *Alter_functionContext) + + // ExitAlter_function_signature is called when exiting the alter_function_signature production. + ExitAlter_function_signature(c *Alter_function_signatureContext) + + // ExitData_type_list is called when exiting the data_type_list production. + ExitData_type_list(c *Data_type_listContext) + + // ExitAlter_masking_policy is called when exiting the alter_masking_policy production. + ExitAlter_masking_policy(c *Alter_masking_policyContext) + + // ExitAlter_materialized_view is called when exiting the alter_materialized_view production. + ExitAlter_materialized_view(c *Alter_materialized_viewContext) + + // ExitAlter_network_policy is called when exiting the alter_network_policy production. + ExitAlter_network_policy(c *Alter_network_policyContext) + + // ExitAlter_notification_integration is called when exiting the alter_notification_integration production. + ExitAlter_notification_integration(c *Alter_notification_integrationContext) + + // ExitAlter_pipe is called when exiting the alter_pipe production. + ExitAlter_pipe(c *Alter_pipeContext) + + // ExitAlter_procedure is called when exiting the alter_procedure production. + ExitAlter_procedure(c *Alter_procedureContext) + + // ExitAlter_replication_group is called when exiting the alter_replication_group production. + ExitAlter_replication_group(c *Alter_replication_groupContext) + + // ExitCredit_quota is called when exiting the credit_quota production. + ExitCredit_quota(c *Credit_quotaContext) + + // ExitFrequency is called when exiting the frequency production. + ExitFrequency(c *FrequencyContext) + + // ExitNotify_users is called when exiting the notify_users production. + ExitNotify_users(c *Notify_usersContext) + + // ExitTriggerDefinition is called when exiting the triggerDefinition production. + ExitTriggerDefinition(c *TriggerDefinitionContext) + + // ExitAlter_resource_monitor is called when exiting the alter_resource_monitor production. + ExitAlter_resource_monitor(c *Alter_resource_monitorContext) + + // ExitAlter_role is called when exiting the alter_role production. + ExitAlter_role(c *Alter_roleContext) + + // ExitAlter_row_access_policy is called when exiting the alter_row_access_policy production. + ExitAlter_row_access_policy(c *Alter_row_access_policyContext) + + // ExitAlter_schema is called when exiting the alter_schema production. + ExitAlter_schema(c *Alter_schemaContext) + + // ExitSchema_property is called when exiting the schema_property production. + ExitSchema_property(c *Schema_propertyContext) + + // ExitAlter_security_integration is called when exiting the alter_security_integration production. + ExitAlter_security_integration(c *Alter_security_integrationContext) + + // ExitAlter_security_integration_external_oauth is called when exiting the alter_security_integration_external_oauth production. + ExitAlter_security_integration_external_oauth(c *Alter_security_integration_external_oauthContext) + + // ExitSecurity_integration_external_oauth_property is called when exiting the security_integration_external_oauth_property production. + ExitSecurity_integration_external_oauth_property(c *Security_integration_external_oauth_propertyContext) + + // ExitAlter_security_integration_snowflake_oauth is called when exiting the alter_security_integration_snowflake_oauth production. + ExitAlter_security_integration_snowflake_oauth(c *Alter_security_integration_snowflake_oauthContext) + + // ExitSecurity_integration_snowflake_oauth_property is called when exiting the security_integration_snowflake_oauth_property production. + ExitSecurity_integration_snowflake_oauth_property(c *Security_integration_snowflake_oauth_propertyContext) + + // ExitAlter_security_integration_saml2 is called when exiting the alter_security_integration_saml2 production. + ExitAlter_security_integration_saml2(c *Alter_security_integration_saml2Context) + + // ExitAlter_security_integration_scim is called when exiting the alter_security_integration_scim production. + ExitAlter_security_integration_scim(c *Alter_security_integration_scimContext) + + // ExitSecurity_integration_scim_property is called when exiting the security_integration_scim_property production. + ExitSecurity_integration_scim_property(c *Security_integration_scim_propertyContext) + + // ExitAlter_sequence is called when exiting the alter_sequence production. + ExitAlter_sequence(c *Alter_sequenceContext) + + // ExitAlter_session is called when exiting the alter_session production. + ExitAlter_session(c *Alter_sessionContext) + + // ExitAlter_session_policy is called when exiting the alter_session_policy production. + ExitAlter_session_policy(c *Alter_session_policyContext) + + // ExitAlter_share is called when exiting the alter_share production. + ExitAlter_share(c *Alter_shareContext) + + // ExitAlter_stage is called when exiting the alter_stage production. + ExitAlter_stage(c *Alter_stageContext) + + // ExitAlter_storage_integration is called when exiting the alter_storage_integration production. + ExitAlter_storage_integration(c *Alter_storage_integrationContext) + + // ExitAlter_stream is called when exiting the alter_stream production. + ExitAlter_stream(c *Alter_streamContext) + + // ExitAlter_table is called when exiting the alter_table production. + ExitAlter_table(c *Alter_tableContext) + + // ExitClustering_action is called when exiting the clustering_action production. + ExitClustering_action(c *Clustering_actionContext) + + // ExitTable_column_action is called when exiting the table_column_action production. + ExitTable_column_action(c *Table_column_actionContext) + + // ExitInline_constraint is called when exiting the inline_constraint production. + ExitInline_constraint(c *Inline_constraintContext) + + // ExitConstraint_properties is called when exiting the constraint_properties production. + ExitConstraint_properties(c *Constraint_propertiesContext) + + // ExitExt_table_column_action is called when exiting the ext_table_column_action production. + ExitExt_table_column_action(c *Ext_table_column_actionContext) + + // ExitConstraint_action is called when exiting the constraint_action production. + ExitConstraint_action(c *Constraint_actionContext) + + // ExitSearch_optimization_action is called when exiting the search_optimization_action production. + ExitSearch_optimization_action(c *Search_optimization_actionContext) + + // ExitSearch_method_with_target is called when exiting the search_method_with_target production. + ExitSearch_method_with_target(c *Search_method_with_targetContext) + + // ExitAlter_table_alter_column is called when exiting the alter_table_alter_column production. + ExitAlter_table_alter_column(c *Alter_table_alter_columnContext) + + // ExitAlter_column_decl_list is called when exiting the alter_column_decl_list production. + ExitAlter_column_decl_list(c *Alter_column_decl_listContext) + + // ExitAlter_column_decl is called when exiting the alter_column_decl production. + ExitAlter_column_decl(c *Alter_column_declContext) + + // ExitAlter_column_opts is called when exiting the alter_column_opts production. + ExitAlter_column_opts(c *Alter_column_optsContext) + + // ExitColumn_set_tags is called when exiting the column_set_tags production. + ExitColumn_set_tags(c *Column_set_tagsContext) + + // ExitColumn_unset_tags is called when exiting the column_unset_tags production. + ExitColumn_unset_tags(c *Column_unset_tagsContext) + + // ExitAlter_tag is called when exiting the alter_tag production. + ExitAlter_tag(c *Alter_tagContext) + + // ExitAlter_task is called when exiting the alter_task production. + ExitAlter_task(c *Alter_taskContext) + + // ExitAlter_user is called when exiting the alter_user production. + ExitAlter_user(c *Alter_userContext) + + // ExitAlter_view is called when exiting the alter_view production. + ExitAlter_view(c *Alter_viewContext) + + // ExitAlter_modify is called when exiting the alter_modify production. + ExitAlter_modify(c *Alter_modifyContext) + + // ExitAlter_warehouse is called when exiting the alter_warehouse production. + ExitAlter_warehouse(c *Alter_warehouseContext) + + // ExitAlter_connection_opts is called when exiting the alter_connection_opts production. + ExitAlter_connection_opts(c *Alter_connection_optsContext) + + // ExitAlter_user_opts is called when exiting the alter_user_opts production. + ExitAlter_user_opts(c *Alter_user_optsContext) + + // ExitAlter_tag_opts is called when exiting the alter_tag_opts production. + ExitAlter_tag_opts(c *Alter_tag_optsContext) + + // ExitAlter_network_policy_opts is called when exiting the alter_network_policy_opts production. + ExitAlter_network_policy_opts(c *Alter_network_policy_optsContext) + + // ExitAlter_warehouse_opts is called when exiting the alter_warehouse_opts production. + ExitAlter_warehouse_opts(c *Alter_warehouse_optsContext) + + // ExitAlter_account_opts is called when exiting the alter_account_opts production. + ExitAlter_account_opts(c *Alter_account_optsContext) + + // ExitSet_tags is called when exiting the set_tags production. + ExitSet_tags(c *Set_tagsContext) + + // ExitTag_decl_list is called when exiting the tag_decl_list production. + ExitTag_decl_list(c *Tag_decl_listContext) + + // ExitUnset_tags is called when exiting the unset_tags production. + ExitUnset_tags(c *Unset_tagsContext) + + // ExitCreate_command is called when exiting the create_command production. + ExitCreate_command(c *Create_commandContext) + + // ExitCreate_account is called when exiting the create_account production. + ExitCreate_account(c *Create_accountContext) + + // ExitCreate_alert is called when exiting the create_alert production. + ExitCreate_alert(c *Create_alertContext) + + // ExitAlert_condition is called when exiting the alert_condition production. + ExitAlert_condition(c *Alert_conditionContext) + + // ExitAlert_action is called when exiting the alert_action production. + ExitAlert_action(c *Alert_actionContext) + + // ExitCreate_api_integration is called when exiting the create_api_integration production. + ExitCreate_api_integration(c *Create_api_integrationContext) + + // ExitCreate_object_clone is called when exiting the create_object_clone production. + ExitCreate_object_clone(c *Create_object_cloneContext) + + // ExitCreate_connection is called when exiting the create_connection production. + ExitCreate_connection(c *Create_connectionContext) + + // ExitCreate_database is called when exiting the create_database production. + ExitCreate_database(c *Create_databaseContext) + + // ExitCreate_dynamic_table is called when exiting the create_dynamic_table production. + ExitCreate_dynamic_table(c *Create_dynamic_tableContext) + + // ExitClone_at_before is called when exiting the clone_at_before production. + ExitClone_at_before(c *Clone_at_beforeContext) + + // ExitAt_before1 is called when exiting the at_before1 production. + ExitAt_before1(c *At_before1Context) + + // ExitHeader_decl is called when exiting the header_decl production. + ExitHeader_decl(c *Header_declContext) + + // ExitCompression_type is called when exiting the compression_type production. + ExitCompression_type(c *Compression_typeContext) + + // ExitCompression is called when exiting the compression production. + ExitCompression(c *CompressionContext) + + // ExitCreate_external_function is called when exiting the create_external_function production. + ExitCreate_external_function(c *Create_external_functionContext) + + // ExitCreate_external_table is called when exiting the create_external_table production. + ExitCreate_external_table(c *Create_external_tableContext) + + // ExitExternal_table_column_decl is called when exiting the external_table_column_decl production. + ExitExternal_table_column_decl(c *External_table_column_declContext) + + // ExitExternal_table_column_decl_list is called when exiting the external_table_column_decl_list production. + ExitExternal_table_column_decl_list(c *External_table_column_decl_listContext) + + // ExitFull_acct is called when exiting the full_acct production. + ExitFull_acct(c *Full_acctContext) + + // ExitIntegration_type_name is called when exiting the integration_type_name production. + ExitIntegration_type_name(c *Integration_type_nameContext) + + // ExitCreate_failover_group is called when exiting the create_failover_group production. + ExitCreate_failover_group(c *Create_failover_groupContext) + + // ExitType_fileformat is called when exiting the type_fileformat production. + ExitType_fileformat(c *Type_fileformatContext) + + // ExitCreate_file_format is called when exiting the create_file_format production. + ExitCreate_file_format(c *Create_file_formatContext) + + // ExitArg_decl is called when exiting the arg_decl production. + ExitArg_decl(c *Arg_declContext) + + // ExitCol_decl is called when exiting the col_decl production. + ExitCol_decl(c *Col_declContext) + + // ExitFunction_definition is called when exiting the function_definition production. + ExitFunction_definition(c *Function_definitionContext) + + // ExitCreate_function is called when exiting the create_function production. + ExitCreate_function(c *Create_functionContext) + + // ExitCreate_managed_account is called when exiting the create_managed_account production. + ExitCreate_managed_account(c *Create_managed_accountContext) + + // ExitCreate_masking_policy is called when exiting the create_masking_policy production. + ExitCreate_masking_policy(c *Create_masking_policyContext) + + // ExitTag_decl is called when exiting the tag_decl production. + ExitTag_decl(c *Tag_declContext) + + // ExitColumn_list_in_parentheses is called when exiting the column_list_in_parentheses production. + ExitColumn_list_in_parentheses(c *Column_list_in_parenthesesContext) + + // ExitCreate_materialized_view is called when exiting the create_materialized_view production. + ExitCreate_materialized_view(c *Create_materialized_viewContext) + + // ExitCreate_network_policy is called when exiting the create_network_policy production. + ExitCreate_network_policy(c *Create_network_policyContext) + + // ExitCloud_provider_params_auto is called when exiting the cloud_provider_params_auto production. + ExitCloud_provider_params_auto(c *Cloud_provider_params_autoContext) + + // ExitCloud_provider_params_push is called when exiting the cloud_provider_params_push production. + ExitCloud_provider_params_push(c *Cloud_provider_params_pushContext) + + // ExitCreate_notification_integration is called when exiting the create_notification_integration production. + ExitCreate_notification_integration(c *Create_notification_integrationContext) + + // ExitCreate_pipe is called when exiting the create_pipe production. + ExitCreate_pipe(c *Create_pipeContext) + + // ExitCaller_owner is called when exiting the caller_owner production. + ExitCaller_owner(c *Caller_ownerContext) + + // ExitExecuta_as is called when exiting the executa_as production. + ExitExecuta_as(c *Executa_asContext) + + // ExitProcedure_definition is called when exiting the procedure_definition production. + ExitProcedure_definition(c *Procedure_definitionContext) + + // ExitCreate_procedure is called when exiting the create_procedure production. + ExitCreate_procedure(c *Create_procedureContext) + + // ExitCreate_replication_group is called when exiting the create_replication_group production. + ExitCreate_replication_group(c *Create_replication_groupContext) + + // ExitCreate_resource_monitor is called when exiting the create_resource_monitor production. + ExitCreate_resource_monitor(c *Create_resource_monitorContext) + + // ExitCreate_role is called when exiting the create_role production. + ExitCreate_role(c *Create_roleContext) + + // ExitCreate_row_access_policy is called when exiting the create_row_access_policy production. + ExitCreate_row_access_policy(c *Create_row_access_policyContext) + + // ExitCreate_schema is called when exiting the create_schema production. + ExitCreate_schema(c *Create_schemaContext) + + // ExitCreate_security_integration_external_oauth is called when exiting the create_security_integration_external_oauth production. + ExitCreate_security_integration_external_oauth(c *Create_security_integration_external_oauthContext) + + // ExitImplicit_none is called when exiting the implicit_none production. + ExitImplicit_none(c *Implicit_noneContext) + + // ExitCreate_security_integration_snowflake_oauth is called when exiting the create_security_integration_snowflake_oauth production. + ExitCreate_security_integration_snowflake_oauth(c *Create_security_integration_snowflake_oauthContext) + + // ExitCreate_security_integration_saml2 is called when exiting the create_security_integration_saml2 production. + ExitCreate_security_integration_saml2(c *Create_security_integration_saml2Context) + + // ExitCreate_security_integration_scim is called when exiting the create_security_integration_scim production. + ExitCreate_security_integration_scim(c *Create_security_integration_scimContext) + + // ExitNetwork_policy is called when exiting the network_policy production. + ExitNetwork_policy(c *Network_policyContext) + + // ExitPartner_application is called when exiting the partner_application production. + ExitPartner_application(c *Partner_applicationContext) + + // ExitStart_with is called when exiting the start_with production. + ExitStart_with(c *Start_withContext) + + // ExitIncrement_by is called when exiting the increment_by production. + ExitIncrement_by(c *Increment_byContext) + + // ExitCreate_sequence is called when exiting the create_sequence production. + ExitCreate_sequence(c *Create_sequenceContext) + + // ExitCreate_session_policy is called when exiting the create_session_policy production. + ExitCreate_session_policy(c *Create_session_policyContext) + + // ExitCreate_share is called when exiting the create_share production. + ExitCreate_share(c *Create_shareContext) + + // ExitCharacter is called when exiting the character production. + ExitCharacter(c *CharacterContext) + + // ExitFormat_type_options is called when exiting the format_type_options production. + ExitFormat_type_options(c *Format_type_optionsContext) + + // ExitCopy_options is called when exiting the copy_options production. + ExitCopy_options(c *Copy_optionsContext) + + // ExitInternal_stage_params is called when exiting the internal_stage_params production. + ExitInternal_stage_params(c *Internal_stage_paramsContext) + + // ExitStage_type is called when exiting the stage_type production. + ExitStage_type(c *Stage_typeContext) + + // ExitStage_master_key is called when exiting the stage_master_key production. + ExitStage_master_key(c *Stage_master_keyContext) + + // ExitStage_kms_key is called when exiting the stage_kms_key production. + ExitStage_kms_key(c *Stage_kms_keyContext) + + // ExitStage_encryption_opts_aws is called when exiting the stage_encryption_opts_aws production. + ExitStage_encryption_opts_aws(c *Stage_encryption_opts_awsContext) + + // ExitAws_token is called when exiting the aws_token production. + ExitAws_token(c *Aws_tokenContext) + + // ExitAws_key_id is called when exiting the aws_key_id production. + ExitAws_key_id(c *Aws_key_idContext) + + // ExitAws_secret_key is called when exiting the aws_secret_key production. + ExitAws_secret_key(c *Aws_secret_keyContext) + + // ExitAws_role is called when exiting the aws_role production. + ExitAws_role(c *Aws_roleContext) + + // ExitExternal_stage_params is called when exiting the external_stage_params production. + ExitExternal_stage_params(c *External_stage_paramsContext) + + // ExitTrue_false is called when exiting the true_false production. + ExitTrue_false(c *True_falseContext) + + // ExitEnable is called when exiting the enable production. + ExitEnable(c *EnableContext) + + // ExitRefresh_on_create is called when exiting the refresh_on_create production. + ExitRefresh_on_create(c *Refresh_on_createContext) + + // ExitAuto_refresh is called when exiting the auto_refresh production. + ExitAuto_refresh(c *Auto_refreshContext) + + // ExitNotification_integration is called when exiting the notification_integration production. + ExitNotification_integration(c *Notification_integrationContext) + + // ExitDirectory_table_params is called when exiting the directory_table_params production. + ExitDirectory_table_params(c *Directory_table_paramsContext) + + // ExitCreate_stage is called when exiting the create_stage production. + ExitCreate_stage(c *Create_stageContext) + + // ExitCloud_provider_params is called when exiting the cloud_provider_params production. + ExitCloud_provider_params(c *Cloud_provider_paramsContext) + + // ExitCloud_provider_params2 is called when exiting the cloud_provider_params2 production. + ExitCloud_provider_params2(c *Cloud_provider_params2Context) + + // ExitCloud_provider_params3 is called when exiting the cloud_provider_params3 production. + ExitCloud_provider_params3(c *Cloud_provider_params3Context) + + // ExitCreate_storage_integration is called when exiting the create_storage_integration production. + ExitCreate_storage_integration(c *Create_storage_integrationContext) + + // ExitCopy_grants is called when exiting the copy_grants production. + ExitCopy_grants(c *Copy_grantsContext) + + // ExitAppend_only is called when exiting the append_only production. + ExitAppend_only(c *Append_onlyContext) + + // ExitInsert_only is called when exiting the insert_only production. + ExitInsert_only(c *Insert_onlyContext) + + // ExitShow_initial_rows is called when exiting the show_initial_rows production. + ExitShow_initial_rows(c *Show_initial_rowsContext) + + // ExitStream_time is called when exiting the stream_time production. + ExitStream_time(c *Stream_timeContext) + + // ExitCreate_stream is called when exiting the create_stream production. + ExitCreate_stream(c *Create_streamContext) + + // ExitTemporary is called when exiting the temporary production. + ExitTemporary(c *TemporaryContext) + + // ExitTable_type is called when exiting the table_type production. + ExitTable_type(c *Table_typeContext) + + // ExitWith_tags is called when exiting the with_tags production. + ExitWith_tags(c *With_tagsContext) + + // ExitWith_row_access_policy is called when exiting the with_row_access_policy production. + ExitWith_row_access_policy(c *With_row_access_policyContext) + + // ExitCluster_by is called when exiting the cluster_by production. + ExitCluster_by(c *Cluster_byContext) + + // ExitChange_tracking is called when exiting the change_tracking production. + ExitChange_tracking(c *Change_trackingContext) + + // ExitWith_masking_policy is called when exiting the with_masking_policy production. + ExitWith_masking_policy(c *With_masking_policyContext) + + // ExitCollate is called when exiting the collate production. + ExitCollate(c *CollateContext) + + // ExitNot_null is called when exiting the not_null production. + ExitNot_null(c *Not_nullContext) + + // ExitDefault_value is called when exiting the default_value production. + ExitDefault_value(c *Default_valueContext) + + // ExitForeign_key is called when exiting the foreign_key production. + ExitForeign_key(c *Foreign_keyContext) + + // ExitOut_of_line_constraint is called when exiting the out_of_line_constraint production. + ExitOut_of_line_constraint(c *Out_of_line_constraintContext) + + // ExitFull_col_decl is called when exiting the full_col_decl production. + ExitFull_col_decl(c *Full_col_declContext) + + // ExitColumn_decl_item is called when exiting the column_decl_item production. + ExitColumn_decl_item(c *Column_decl_itemContext) + + // ExitColumn_decl_item_list is called when exiting the column_decl_item_list production. + ExitColumn_decl_item_list(c *Column_decl_item_listContext) + + // ExitCreate_table is called when exiting the create_table production. + ExitCreate_table(c *Create_tableContext) + + // ExitCreate_table_as_select is called when exiting the create_table_as_select production. + ExitCreate_table_as_select(c *Create_table_as_selectContext) + + // ExitCreate_tag is called when exiting the create_tag production. + ExitCreate_tag(c *Create_tagContext) + + // ExitSession_parameter is called when exiting the session_parameter production. + ExitSession_parameter(c *Session_parameterContext) + + // ExitSession_parameter_list is called when exiting the session_parameter_list production. + ExitSession_parameter_list(c *Session_parameter_listContext) + + // ExitSession_parameter_init_list is called when exiting the session_parameter_init_list production. + ExitSession_parameter_init_list(c *Session_parameter_init_listContext) + + // ExitSession_parameter_init is called when exiting the session_parameter_init production. + ExitSession_parameter_init(c *Session_parameter_initContext) + + // ExitCreate_task is called when exiting the create_task production. + ExitCreate_task(c *Create_taskContext) + + // ExitSql is called when exiting the sql production. + ExitSql(c *SqlContext) + + // ExitCall is called when exiting the call production. + ExitCall(c *CallContext) + + // ExitCreate_user is called when exiting the create_user production. + ExitCreate_user(c *Create_userContext) + + // ExitView_col is called when exiting the view_col production. + ExitView_col(c *View_colContext) + + // ExitCreate_view is called when exiting the create_view production. + ExitCreate_view(c *Create_viewContext) + + // ExitCreate_warehouse is called when exiting the create_warehouse production. + ExitCreate_warehouse(c *Create_warehouseContext) + + // ExitWh_properties is called when exiting the wh_properties production. + ExitWh_properties(c *Wh_propertiesContext) + + // ExitWh_params is called when exiting the wh_params production. + ExitWh_params(c *Wh_paramsContext) + + // ExitTrigger_definition is called when exiting the trigger_definition production. + ExitTrigger_definition(c *Trigger_definitionContext) + + // ExitObject_type_name is called when exiting the object_type_name production. + ExitObject_type_name(c *Object_type_nameContext) + + // ExitObject_type_plural is called when exiting the object_type_plural production. + ExitObject_type_plural(c *Object_type_pluralContext) + + // ExitDrop_command is called when exiting the drop_command production. + ExitDrop_command(c *Drop_commandContext) + + // ExitDrop_object is called when exiting the drop_object production. + ExitDrop_object(c *Drop_objectContext) + + // ExitDrop_alert is called when exiting the drop_alert production. + ExitDrop_alert(c *Drop_alertContext) + + // ExitDrop_connection is called when exiting the drop_connection production. + ExitDrop_connection(c *Drop_connectionContext) + + // ExitDrop_database is called when exiting the drop_database production. + ExitDrop_database(c *Drop_databaseContext) + + // ExitDrop_dynamic_table is called when exiting the drop_dynamic_table production. + ExitDrop_dynamic_table(c *Drop_dynamic_tableContext) + + // ExitDrop_external_table is called when exiting the drop_external_table production. + ExitDrop_external_table(c *Drop_external_tableContext) + + // ExitDrop_failover_group is called when exiting the drop_failover_group production. + ExitDrop_failover_group(c *Drop_failover_groupContext) + + // ExitDrop_file_format is called when exiting the drop_file_format production. + ExitDrop_file_format(c *Drop_file_formatContext) + + // ExitDrop_function is called when exiting the drop_function production. + ExitDrop_function(c *Drop_functionContext) + + // ExitDrop_integration is called when exiting the drop_integration production. + ExitDrop_integration(c *Drop_integrationContext) + + // ExitDrop_managed_account is called when exiting the drop_managed_account production. + ExitDrop_managed_account(c *Drop_managed_accountContext) + + // ExitDrop_masking_policy is called when exiting the drop_masking_policy production. + ExitDrop_masking_policy(c *Drop_masking_policyContext) + + // ExitDrop_materialized_view is called when exiting the drop_materialized_view production. + ExitDrop_materialized_view(c *Drop_materialized_viewContext) + + // ExitDrop_network_policy is called when exiting the drop_network_policy production. + ExitDrop_network_policy(c *Drop_network_policyContext) + + // ExitDrop_pipe is called when exiting the drop_pipe production. + ExitDrop_pipe(c *Drop_pipeContext) + + // ExitDrop_procedure is called when exiting the drop_procedure production. + ExitDrop_procedure(c *Drop_procedureContext) + + // ExitDrop_replication_group is called when exiting the drop_replication_group production. + ExitDrop_replication_group(c *Drop_replication_groupContext) + + // ExitDrop_resource_monitor is called when exiting the drop_resource_monitor production. + ExitDrop_resource_monitor(c *Drop_resource_monitorContext) + + // ExitDrop_role is called when exiting the drop_role production. + ExitDrop_role(c *Drop_roleContext) + + // ExitDrop_row_access_policy is called when exiting the drop_row_access_policy production. + ExitDrop_row_access_policy(c *Drop_row_access_policyContext) + + // ExitDrop_schema is called when exiting the drop_schema production. + ExitDrop_schema(c *Drop_schemaContext) + + // ExitDrop_sequence is called when exiting the drop_sequence production. + ExitDrop_sequence(c *Drop_sequenceContext) + + // ExitDrop_session_policy is called when exiting the drop_session_policy production. + ExitDrop_session_policy(c *Drop_session_policyContext) + + // ExitDrop_share is called when exiting the drop_share production. + ExitDrop_share(c *Drop_shareContext) + + // ExitDrop_stage is called when exiting the drop_stage production. + ExitDrop_stage(c *Drop_stageContext) + + // ExitDrop_stream is called when exiting the drop_stream production. + ExitDrop_stream(c *Drop_streamContext) + + // ExitDrop_table is called when exiting the drop_table production. + ExitDrop_table(c *Drop_tableContext) + + // ExitDrop_tag is called when exiting the drop_tag production. + ExitDrop_tag(c *Drop_tagContext) + + // ExitDrop_task is called when exiting the drop_task production. + ExitDrop_task(c *Drop_taskContext) + + // ExitDrop_user is called when exiting the drop_user production. + ExitDrop_user(c *Drop_userContext) + + // ExitDrop_view is called when exiting the drop_view production. + ExitDrop_view(c *Drop_viewContext) + + // ExitDrop_warehouse is called when exiting the drop_warehouse production. + ExitDrop_warehouse(c *Drop_warehouseContext) + + // ExitCascade_restrict is called when exiting the cascade_restrict production. + ExitCascade_restrict(c *Cascade_restrictContext) + + // ExitArg_types is called when exiting the arg_types production. + ExitArg_types(c *Arg_typesContext) + + // ExitUndrop_command is called when exiting the undrop_command production. + ExitUndrop_command(c *Undrop_commandContext) + + // ExitUndrop_database is called when exiting the undrop_database production. + ExitUndrop_database(c *Undrop_databaseContext) + + // ExitUndrop_dynamic_table is called when exiting the undrop_dynamic_table production. + ExitUndrop_dynamic_table(c *Undrop_dynamic_tableContext) + + // ExitUndrop_schema is called when exiting the undrop_schema production. + ExitUndrop_schema(c *Undrop_schemaContext) + + // ExitUndrop_table is called when exiting the undrop_table production. + ExitUndrop_table(c *Undrop_tableContext) + + // ExitUndrop_tag is called when exiting the undrop_tag production. + ExitUndrop_tag(c *Undrop_tagContext) + + // ExitUse_command is called when exiting the use_command production. + ExitUse_command(c *Use_commandContext) + + // ExitUse_database is called when exiting the use_database production. + ExitUse_database(c *Use_databaseContext) + + // ExitUse_role is called when exiting the use_role production. + ExitUse_role(c *Use_roleContext) + + // ExitUse_schema is called when exiting the use_schema production. + ExitUse_schema(c *Use_schemaContext) + + // ExitUse_secondary_roles is called when exiting the use_secondary_roles production. + ExitUse_secondary_roles(c *Use_secondary_rolesContext) + + // ExitUse_warehouse is called when exiting the use_warehouse production. + ExitUse_warehouse(c *Use_warehouseContext) + + // ExitComment_clause is called when exiting the comment_clause production. + ExitComment_clause(c *Comment_clauseContext) + + // ExitIf_suspended is called when exiting the if_suspended production. + ExitIf_suspended(c *If_suspendedContext) + + // ExitIf_exists is called when exiting the if_exists production. + ExitIf_exists(c *If_existsContext) + + // ExitIf_not_exists is called when exiting the if_not_exists production. + ExitIf_not_exists(c *If_not_existsContext) + + // ExitOr_replace is called when exiting the or_replace production. + ExitOr_replace(c *Or_replaceContext) + + // ExitDescribe is called when exiting the describe production. + ExitDescribe(c *DescribeContext) + + // ExitDescribe_command is called when exiting the describe_command production. + ExitDescribe_command(c *Describe_commandContext) + + // ExitDescribe_alert is called when exiting the describe_alert production. + ExitDescribe_alert(c *Describe_alertContext) + + // ExitDescribe_database is called when exiting the describe_database production. + ExitDescribe_database(c *Describe_databaseContext) + + // ExitDescribe_dynamic_table is called when exiting the describe_dynamic_table production. + ExitDescribe_dynamic_table(c *Describe_dynamic_tableContext) + + // ExitDescribe_external_table is called when exiting the describe_external_table production. + ExitDescribe_external_table(c *Describe_external_tableContext) + + // ExitDescribe_file_format is called when exiting the describe_file_format production. + ExitDescribe_file_format(c *Describe_file_formatContext) + + // ExitDescribe_function is called when exiting the describe_function production. + ExitDescribe_function(c *Describe_functionContext) + + // ExitDescribe_integration is called when exiting the describe_integration production. + ExitDescribe_integration(c *Describe_integrationContext) + + // ExitDescribe_masking_policy is called when exiting the describe_masking_policy production. + ExitDescribe_masking_policy(c *Describe_masking_policyContext) + + // ExitDescribe_materialized_view is called when exiting the describe_materialized_view production. + ExitDescribe_materialized_view(c *Describe_materialized_viewContext) + + // ExitDescribe_network_policy is called when exiting the describe_network_policy production. + ExitDescribe_network_policy(c *Describe_network_policyContext) + + // ExitDescribe_pipe is called when exiting the describe_pipe production. + ExitDescribe_pipe(c *Describe_pipeContext) + + // ExitDescribe_procedure is called when exiting the describe_procedure production. + ExitDescribe_procedure(c *Describe_procedureContext) + + // ExitDescribe_result is called when exiting the describe_result production. + ExitDescribe_result(c *Describe_resultContext) + + // ExitDescribe_row_access_policy is called when exiting the describe_row_access_policy production. + ExitDescribe_row_access_policy(c *Describe_row_access_policyContext) + + // ExitDescribe_schema is called when exiting the describe_schema production. + ExitDescribe_schema(c *Describe_schemaContext) + + // ExitDescribe_search_optimization is called when exiting the describe_search_optimization production. + ExitDescribe_search_optimization(c *Describe_search_optimizationContext) + + // ExitDescribe_sequence is called when exiting the describe_sequence production. + ExitDescribe_sequence(c *Describe_sequenceContext) + + // ExitDescribe_session_policy is called when exiting the describe_session_policy production. + ExitDescribe_session_policy(c *Describe_session_policyContext) + + // ExitDescribe_share is called when exiting the describe_share production. + ExitDescribe_share(c *Describe_shareContext) + + // ExitDescribe_stage is called when exiting the describe_stage production. + ExitDescribe_stage(c *Describe_stageContext) + + // ExitDescribe_stream is called when exiting the describe_stream production. + ExitDescribe_stream(c *Describe_streamContext) + + // ExitDescribe_table is called when exiting the describe_table production. + ExitDescribe_table(c *Describe_tableContext) + + // ExitDescribe_task is called when exiting the describe_task production. + ExitDescribe_task(c *Describe_taskContext) + + // ExitDescribe_transaction is called when exiting the describe_transaction production. + ExitDescribe_transaction(c *Describe_transactionContext) + + // ExitDescribe_user is called when exiting the describe_user production. + ExitDescribe_user(c *Describe_userContext) + + // ExitDescribe_view is called when exiting the describe_view production. + ExitDescribe_view(c *Describe_viewContext) + + // ExitDescribe_warehouse is called when exiting the describe_warehouse production. + ExitDescribe_warehouse(c *Describe_warehouseContext) + + // ExitShow_command is called when exiting the show_command production. + ExitShow_command(c *Show_commandContext) + + // ExitShow_alerts is called when exiting the show_alerts production. + ExitShow_alerts(c *Show_alertsContext) + + // ExitShow_columns is called when exiting the show_columns production. + ExitShow_columns(c *Show_columnsContext) + + // ExitShow_connections is called when exiting the show_connections production. + ExitShow_connections(c *Show_connectionsContext) + + // ExitStarts_with is called when exiting the starts_with production. + ExitStarts_with(c *Starts_withContext) + + // ExitLimit_rows is called when exiting the limit_rows production. + ExitLimit_rows(c *Limit_rowsContext) + + // ExitShow_databases is called when exiting the show_databases production. + ExitShow_databases(c *Show_databasesContext) + + // ExitShow_databases_in_failover_group is called when exiting the show_databases_in_failover_group production. + ExitShow_databases_in_failover_group(c *Show_databases_in_failover_groupContext) + + // ExitShow_databases_in_replication_group is called when exiting the show_databases_in_replication_group production. + ExitShow_databases_in_replication_group(c *Show_databases_in_replication_groupContext) + + // ExitShow_delegated_authorizations is called when exiting the show_delegated_authorizations production. + ExitShow_delegated_authorizations(c *Show_delegated_authorizationsContext) + + // ExitShow_external_functions is called when exiting the show_external_functions production. + ExitShow_external_functions(c *Show_external_functionsContext) + + // ExitShow_dynamic_tables is called when exiting the show_dynamic_tables production. + ExitShow_dynamic_tables(c *Show_dynamic_tablesContext) + + // ExitShow_external_tables is called when exiting the show_external_tables production. + ExitShow_external_tables(c *Show_external_tablesContext) + + // ExitShow_failover_groups is called when exiting the show_failover_groups production. + ExitShow_failover_groups(c *Show_failover_groupsContext) + + // ExitShow_file_formats is called when exiting the show_file_formats production. + ExitShow_file_formats(c *Show_file_formatsContext) + + // ExitShow_functions is called when exiting the show_functions production. + ExitShow_functions(c *Show_functionsContext) + + // ExitShow_global_accounts is called when exiting the show_global_accounts production. + ExitShow_global_accounts(c *Show_global_accountsContext) + + // ExitShow_grants is called when exiting the show_grants production. + ExitShow_grants(c *Show_grantsContext) + + // ExitShow_grants_opts is called when exiting the show_grants_opts production. + ExitShow_grants_opts(c *Show_grants_optsContext) + + // ExitShow_integrations is called when exiting the show_integrations production. + ExitShow_integrations(c *Show_integrationsContext) + + // ExitShow_locks is called when exiting the show_locks production. + ExitShow_locks(c *Show_locksContext) + + // ExitShow_managed_accounts is called when exiting the show_managed_accounts production. + ExitShow_managed_accounts(c *Show_managed_accountsContext) + + // ExitShow_masking_policies is called when exiting the show_masking_policies production. + ExitShow_masking_policies(c *Show_masking_policiesContext) + + // ExitIn_obj is called when exiting the in_obj production. + ExitIn_obj(c *In_objContext) + + // ExitIn_obj_2 is called when exiting the in_obj_2 production. + ExitIn_obj_2(c *In_obj_2Context) + + // ExitShow_materialized_views is called when exiting the show_materialized_views production. + ExitShow_materialized_views(c *Show_materialized_viewsContext) + + // ExitShow_network_policies is called when exiting the show_network_policies production. + ExitShow_network_policies(c *Show_network_policiesContext) + + // ExitShow_objects is called when exiting the show_objects production. + ExitShow_objects(c *Show_objectsContext) + + // ExitShow_organization_accounts is called when exiting the show_organization_accounts production. + ExitShow_organization_accounts(c *Show_organization_accountsContext) + + // ExitIn_for is called when exiting the in_for production. + ExitIn_for(c *In_forContext) + + // ExitShow_parameters is called when exiting the show_parameters production. + ExitShow_parameters(c *Show_parametersContext) + + // ExitShow_pipes is called when exiting the show_pipes production. + ExitShow_pipes(c *Show_pipesContext) + + // ExitShow_primary_keys is called when exiting the show_primary_keys production. + ExitShow_primary_keys(c *Show_primary_keysContext) + + // ExitShow_procedures is called when exiting the show_procedures production. + ExitShow_procedures(c *Show_proceduresContext) + + // ExitShow_regions is called when exiting the show_regions production. + ExitShow_regions(c *Show_regionsContext) + + // ExitShow_replication_accounts is called when exiting the show_replication_accounts production. + ExitShow_replication_accounts(c *Show_replication_accountsContext) + + // ExitShow_replication_databases is called when exiting the show_replication_databases production. + ExitShow_replication_databases(c *Show_replication_databasesContext) + + // ExitShow_replication_groups is called when exiting the show_replication_groups production. + ExitShow_replication_groups(c *Show_replication_groupsContext) + + // ExitShow_resource_monitors is called when exiting the show_resource_monitors production. + ExitShow_resource_monitors(c *Show_resource_monitorsContext) + + // ExitShow_roles is called when exiting the show_roles production. + ExitShow_roles(c *Show_rolesContext) + + // ExitShow_row_access_policies is called when exiting the show_row_access_policies production. + ExitShow_row_access_policies(c *Show_row_access_policiesContext) + + // ExitShow_schemas is called when exiting the show_schemas production. + ExitShow_schemas(c *Show_schemasContext) + + // ExitShow_sequences is called when exiting the show_sequences production. + ExitShow_sequences(c *Show_sequencesContext) + + // ExitShow_session_policies is called when exiting the show_session_policies production. + ExitShow_session_policies(c *Show_session_policiesContext) + + // ExitShow_shares is called when exiting the show_shares production. + ExitShow_shares(c *Show_sharesContext) + + // ExitShow_shares_in_failover_group is called when exiting the show_shares_in_failover_group production. + ExitShow_shares_in_failover_group(c *Show_shares_in_failover_groupContext) + + // ExitShow_shares_in_replication_group is called when exiting the show_shares_in_replication_group production. + ExitShow_shares_in_replication_group(c *Show_shares_in_replication_groupContext) + + // ExitShow_stages is called when exiting the show_stages production. + ExitShow_stages(c *Show_stagesContext) + + // ExitShow_streams is called when exiting the show_streams production. + ExitShow_streams(c *Show_streamsContext) + + // ExitShow_tables is called when exiting the show_tables production. + ExitShow_tables(c *Show_tablesContext) + + // ExitShow_tags is called when exiting the show_tags production. + ExitShow_tags(c *Show_tagsContext) + + // ExitShow_tasks is called when exiting the show_tasks production. + ExitShow_tasks(c *Show_tasksContext) + + // ExitShow_transactions is called when exiting the show_transactions production. + ExitShow_transactions(c *Show_transactionsContext) + + // ExitShow_user_functions is called when exiting the show_user_functions production. + ExitShow_user_functions(c *Show_user_functionsContext) + + // ExitShow_users is called when exiting the show_users production. + ExitShow_users(c *Show_usersContext) + + // ExitShow_variables is called when exiting the show_variables production. + ExitShow_variables(c *Show_variablesContext) + + // ExitShow_views is called when exiting the show_views production. + ExitShow_views(c *Show_viewsContext) + + // ExitShow_warehouses is called when exiting the show_warehouses production. + ExitShow_warehouses(c *Show_warehousesContext) + + // ExitLike_pattern is called when exiting the like_pattern production. + ExitLike_pattern(c *Like_patternContext) + + // ExitAccount_identifier is called when exiting the account_identifier production. + ExitAccount_identifier(c *Account_identifierContext) + + // ExitSchema_name is called when exiting the schema_name production. + ExitSchema_name(c *Schema_nameContext) + + // ExitObject_type is called when exiting the object_type production. + ExitObject_type(c *Object_typeContext) + + // ExitObject_type_list is called when exiting the object_type_list production. + ExitObject_type_list(c *Object_type_listContext) + + // ExitTag_value is called when exiting the tag_value production. + ExitTag_value(c *Tag_valueContext) + + // ExitArg_data_type is called when exiting the arg_data_type production. + ExitArg_data_type(c *Arg_data_typeContext) + + // ExitArg_name is called when exiting the arg_name production. + ExitArg_name(c *Arg_nameContext) + + // ExitParam_name is called when exiting the param_name production. + ExitParam_name(c *Param_nameContext) + + // ExitRegion_group_id is called when exiting the region_group_id production. + ExitRegion_group_id(c *Region_group_idContext) + + // ExitSnowflake_region_id is called when exiting the snowflake_region_id production. + ExitSnowflake_region_id(c *Snowflake_region_idContext) + + // ExitString is called when exiting the string production. + ExitString(c *StringContext) + + // ExitString_list is called when exiting the string_list production. + ExitString_list(c *String_listContext) + + // ExitId_ is called when exiting the id_ production. + ExitId_(c *Id_Context) + + // ExitKeyword is called when exiting the keyword production. + ExitKeyword(c *KeywordContext) + + // ExitNon_reserved_words is called when exiting the non_reserved_words production. + ExitNon_reserved_words(c *Non_reserved_wordsContext) + + // ExitBuiltin_function is called when exiting the builtin_function production. + ExitBuiltin_function(c *Builtin_functionContext) + + // ExitList_operator is called when exiting the list_operator production. + ExitList_operator(c *List_operatorContext) + + // ExitBinary_builtin_function is called when exiting the binary_builtin_function production. + ExitBinary_builtin_function(c *Binary_builtin_functionContext) + + // ExitBinary_or_ternary_builtin_function is called when exiting the binary_or_ternary_builtin_function production. + ExitBinary_or_ternary_builtin_function(c *Binary_or_ternary_builtin_functionContext) + + // ExitTernary_builtin_function is called when exiting the ternary_builtin_function production. + ExitTernary_builtin_function(c *Ternary_builtin_functionContext) + + // ExitPattern is called when exiting the pattern production. + ExitPattern(c *PatternContext) + + // ExitColumn_name is called when exiting the column_name production. + ExitColumn_name(c *Column_nameContext) + + // ExitColumn_list is called when exiting the column_list production. + ExitColumn_list(c *Column_listContext) + + // ExitObject_name is called when exiting the object_name production. + ExitObject_name(c *Object_nameContext) + + // ExitNum is called when exiting the num production. + ExitNum(c *NumContext) + + // ExitExpr_list is called when exiting the expr_list production. + ExitExpr_list(c *Expr_listContext) + + // ExitExpr_list_sorted is called when exiting the expr_list_sorted production. + ExitExpr_list_sorted(c *Expr_list_sortedContext) + + // ExitExpr is called when exiting the expr production. + ExitExpr(c *ExprContext) + + // ExitIff_expr is called when exiting the iff_expr production. + ExitIff_expr(c *Iff_exprContext) + + // ExitTrim_expression is called when exiting the trim_expression production. + ExitTrim_expression(c *Trim_expressionContext) + + // ExitTry_cast_expr is called when exiting the try_cast_expr production. + ExitTry_cast_expr(c *Try_cast_exprContext) + + // ExitJson_literal is called when exiting the json_literal production. + ExitJson_literal(c *Json_literalContext) + + // ExitKv_pair is called when exiting the kv_pair production. + ExitKv_pair(c *Kv_pairContext) + + // ExitValue is called when exiting the value production. + ExitValue(c *ValueContext) + + // ExitArr_literal is called when exiting the arr_literal production. + ExitArr_literal(c *Arr_literalContext) + + // ExitData_type is called when exiting the data_type production. + ExitData_type(c *Data_typeContext) + + // ExitPrimitive_expression is called when exiting the primitive_expression production. + ExitPrimitive_expression(c *Primitive_expressionContext) + + // ExitOrder_by_expr is called when exiting the order_by_expr production. + ExitOrder_by_expr(c *Order_by_exprContext) + + // ExitAsc_desc is called when exiting the asc_desc production. + ExitAsc_desc(c *Asc_descContext) + + // ExitOver_clause is called when exiting the over_clause production. + ExitOver_clause(c *Over_clauseContext) + + // ExitFunction_call is called when exiting the function_call production. + ExitFunction_call(c *Function_callContext) + + // ExitRanking_windowed_function is called when exiting the ranking_windowed_function production. + ExitRanking_windowed_function(c *Ranking_windowed_functionContext) + + // ExitAggregate_function is called when exiting the aggregate_function production. + ExitAggregate_function(c *Aggregate_functionContext) + + // ExitLiteral is called when exiting the literal production. + ExitLiteral(c *LiteralContext) + + // ExitSign is called when exiting the sign production. + ExitSign(c *SignContext) + + // ExitFull_column_name is called when exiting the full_column_name production. + ExitFull_column_name(c *Full_column_nameContext) + + // ExitBracket_expression is called when exiting the bracket_expression production. + ExitBracket_expression(c *Bracket_expressionContext) + + // ExitCase_expression is called when exiting the case_expression production. + ExitCase_expression(c *Case_expressionContext) + + // ExitSwitch_search_condition_section is called when exiting the switch_search_condition_section production. + ExitSwitch_search_condition_section(c *Switch_search_condition_sectionContext) + + // ExitSwitch_section is called when exiting the switch_section production. + ExitSwitch_section(c *Switch_sectionContext) + + // ExitQuery_statement is called when exiting the query_statement production. + ExitQuery_statement(c *Query_statementContext) + + // ExitWith_expression is called when exiting the with_expression production. + ExitWith_expression(c *With_expressionContext) + + // ExitCommon_table_expression is called when exiting the common_table_expression production. + ExitCommon_table_expression(c *Common_table_expressionContext) + + // ExitAnchor_clause is called when exiting the anchor_clause production. + ExitAnchor_clause(c *Anchor_clauseContext) + + // ExitRecursive_clause is called when exiting the recursive_clause production. + ExitRecursive_clause(c *Recursive_clauseContext) + + // ExitSelect_statement is called when exiting the select_statement production. + ExitSelect_statement(c *Select_statementContext) + + // ExitSet_operators is called when exiting the set_operators production. + ExitSet_operators(c *Set_operatorsContext) + + // ExitSelect_optional_clauses is called when exiting the select_optional_clauses production. + ExitSelect_optional_clauses(c *Select_optional_clausesContext) + + // ExitSelect_clause is called when exiting the select_clause production. + ExitSelect_clause(c *Select_clauseContext) + + // ExitSelect_top_clause is called when exiting the select_top_clause production. + ExitSelect_top_clause(c *Select_top_clauseContext) + + // ExitSelect_list_no_top is called when exiting the select_list_no_top production. + ExitSelect_list_no_top(c *Select_list_no_topContext) + + // ExitSelect_list_top is called when exiting the select_list_top production. + ExitSelect_list_top(c *Select_list_topContext) + + // ExitSelect_list is called when exiting the select_list production. + ExitSelect_list(c *Select_listContext) + + // ExitSelect_list_elem is called when exiting the select_list_elem production. + ExitSelect_list_elem(c *Select_list_elemContext) + + // ExitColumn_elem is called when exiting the column_elem production. + ExitColumn_elem(c *Column_elemContext) + + // ExitAs_alias is called when exiting the as_alias production. + ExitAs_alias(c *As_aliasContext) + + // ExitExpression_elem is called when exiting the expression_elem production. + ExitExpression_elem(c *Expression_elemContext) + + // ExitColumn_position is called when exiting the column_position production. + ExitColumn_position(c *Column_positionContext) + + // ExitAll_distinct is called when exiting the all_distinct production. + ExitAll_distinct(c *All_distinctContext) + + // ExitTop_clause is called when exiting the top_clause production. + ExitTop_clause(c *Top_clauseContext) + + // ExitInto_clause is called when exiting the into_clause production. + ExitInto_clause(c *Into_clauseContext) + + // ExitVar_list is called when exiting the var_list production. + ExitVar_list(c *Var_listContext) + + // ExitVar is called when exiting the var production. + ExitVar(c *VarContext) + + // ExitFrom_clause is called when exiting the from_clause production. + ExitFrom_clause(c *From_clauseContext) + + // ExitTable_sources is called when exiting the table_sources production. + ExitTable_sources(c *Table_sourcesContext) + + // ExitTable_source is called when exiting the table_source production. + ExitTable_source(c *Table_sourceContext) + + // ExitTable_source_item_joined is called when exiting the table_source_item_joined production. + ExitTable_source_item_joined(c *Table_source_item_joinedContext) + + // ExitObject_ref is called when exiting the object_ref production. + ExitObject_ref(c *Object_refContext) + + // ExitFlatten_table_option is called when exiting the flatten_table_option production. + ExitFlatten_table_option(c *Flatten_table_optionContext) + + // ExitFlatten_table is called when exiting the flatten_table production. + ExitFlatten_table(c *Flatten_tableContext) + + // ExitPrior_list is called when exiting the prior_list production. + ExitPrior_list(c *Prior_listContext) + + // ExitPrior_item is called when exiting the prior_item production. + ExitPrior_item(c *Prior_itemContext) + + // ExitOuter_join is called when exiting the outer_join production. + ExitOuter_join(c *Outer_joinContext) + + // ExitJoin_type is called when exiting the join_type production. + ExitJoin_type(c *Join_typeContext) + + // ExitJoin_clause is called when exiting the join_clause production. + ExitJoin_clause(c *Join_clauseContext) + + // ExitAt_before is called when exiting the at_before production. + ExitAt_before(c *At_beforeContext) + + // ExitEnd is called when exiting the end production. + ExitEnd(c *EndContext) + + // ExitChanges is called when exiting the changes production. + ExitChanges(c *ChangesContext) + + // ExitDefault_append_only is called when exiting the default_append_only production. + ExitDefault_append_only(c *Default_append_onlyContext) + + // ExitPartition_by is called when exiting the partition_by production. + ExitPartition_by(c *Partition_byContext) + + // ExitAlias is called when exiting the alias production. + ExitAlias(c *AliasContext) + + // ExitExpr_alias_list is called when exiting the expr_alias_list production. + ExitExpr_alias_list(c *Expr_alias_listContext) + + // ExitMeasures is called when exiting the measures production. + ExitMeasures(c *MeasuresContext) + + // ExitMatch_opts is called when exiting the match_opts production. + ExitMatch_opts(c *Match_optsContext) + + // ExitRow_match is called when exiting the row_match production. + ExitRow_match(c *Row_matchContext) + + // ExitFirst_last is called when exiting the first_last production. + ExitFirst_last(c *First_lastContext) + + // ExitSymbol is called when exiting the symbol production. + ExitSymbol(c *SymbolContext) + + // ExitAfter_match is called when exiting the after_match production. + ExitAfter_match(c *After_matchContext) + + // ExitSymbol_list is called when exiting the symbol_list production. + ExitSymbol_list(c *Symbol_listContext) + + // ExitDefine is called when exiting the define production. + ExitDefine(c *DefineContext) + + // ExitMatch_recognize is called when exiting the match_recognize production. + ExitMatch_recognize(c *Match_recognizeContext) + + // ExitPivot_unpivot is called when exiting the pivot_unpivot production. + ExitPivot_unpivot(c *Pivot_unpivotContext) + + // ExitColumn_alias_list_in_brackets is called when exiting the column_alias_list_in_brackets production. + ExitColumn_alias_list_in_brackets(c *Column_alias_list_in_bracketsContext) + + // ExitExpr_list_in_parentheses is called when exiting the expr_list_in_parentheses production. + ExitExpr_list_in_parentheses(c *Expr_list_in_parenthesesContext) + + // ExitValues is called when exiting the values production. + ExitValues(c *ValuesContext) + + // ExitSample_method is called when exiting the sample_method production. + ExitSample_method(c *Sample_methodContext) + + // ExitRepeatable_seed is called when exiting the repeatable_seed production. + ExitRepeatable_seed(c *Repeatable_seedContext) + + // ExitSample_opts is called when exiting the sample_opts production. + ExitSample_opts(c *Sample_optsContext) + + // ExitSample is called when exiting the sample production. + ExitSample(c *SampleContext) + + // ExitSearch_condition is called when exiting the search_condition production. + ExitSearch_condition(c *Search_conditionContext) + + // ExitComparison_operator is called when exiting the comparison_operator production. + ExitComparison_operator(c *Comparison_operatorContext) + + // ExitNull_not_null is called when exiting the null_not_null production. + ExitNull_not_null(c *Null_not_nullContext) + + // ExitSubquery is called when exiting the subquery production. + ExitSubquery(c *SubqueryContext) + + // ExitPredicate is called when exiting the predicate production. + ExitPredicate(c *PredicateContext) + + // ExitWhere_clause is called when exiting the where_clause production. + ExitWhere_clause(c *Where_clauseContext) + + // ExitGroup_item is called when exiting the group_item production. + ExitGroup_item(c *Group_itemContext) + + // ExitGroup_by_clause is called when exiting the group_by_clause production. + ExitGroup_by_clause(c *Group_by_clauseContext) + + // ExitHaving_clause is called when exiting the having_clause production. + ExitHaving_clause(c *Having_clauseContext) + + // ExitQualify_clause is called when exiting the qualify_clause production. + ExitQualify_clause(c *Qualify_clauseContext) + + // ExitOrder_item is called when exiting the order_item production. + ExitOrder_item(c *Order_itemContext) + + // ExitOrder_by_clause is called when exiting the order_by_clause production. + ExitOrder_by_clause(c *Order_by_clauseContext) + + // ExitRow_rows is called when exiting the row_rows production. + ExitRow_rows(c *Row_rowsContext) + + // ExitFirst_next is called when exiting the first_next production. + ExitFirst_next(c *First_nextContext) + + // ExitLimit_clause is called when exiting the limit_clause production. + ExitLimit_clause(c *Limit_clauseContext) + + // ExitSupplement_non_reserved_words is called when exiting the supplement_non_reserved_words production. + ExitSupplement_non_reserved_words(c *Supplement_non_reserved_wordsContext) +} diff --git a/snowflake/snowflakeparser_visitor.go b/snowflake/snowflakeparser_visitor.go new file mode 100644 index 0000000..94e4e59 --- /dev/null +++ b/snowflake/snowflakeparser_visitor.go @@ -0,0 +1,1632 @@ +// Code generated from SnowflakeParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package snowflake // SnowflakeParser +import "github.com/antlr4-go/antlr/v4" + +// A complete Visitor for a parse tree produced by SnowflakeParser. +type SnowflakeParserVisitor interface { + antlr.ParseTreeVisitor + + // Visit a parse tree produced by SnowflakeParser#snowflake_file. + VisitSnowflake_file(ctx *Snowflake_fileContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#batch. + VisitBatch(ctx *BatchContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#sql_command. + VisitSql_command(ctx *Sql_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#ddl_command. + VisitDdl_command(ctx *Ddl_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#dml_command. + VisitDml_command(ctx *Dml_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#insert_statement. + VisitInsert_statement(ctx *Insert_statementContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#insert_multi_table_statement. + VisitInsert_multi_table_statement(ctx *Insert_multi_table_statementContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#into_clause2. + VisitInto_clause2(ctx *Into_clause2Context) interface{} + + // Visit a parse tree produced by SnowflakeParser#values_list. + VisitValues_list(ctx *Values_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#value_item. + VisitValue_item(ctx *Value_itemContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#merge_statement. + VisitMerge_statement(ctx *Merge_statementContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#merge_matches. + VisitMerge_matches(ctx *Merge_matchesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#merge_update_delete. + VisitMerge_update_delete(ctx *Merge_update_deleteContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#merge_insert. + VisitMerge_insert(ctx *Merge_insertContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#update_statement. + VisitUpdate_statement(ctx *Update_statementContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#table_or_query. + VisitTable_or_query(ctx *Table_or_queryContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#delete_statement. + VisitDelete_statement(ctx *Delete_statementContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#values_builder. + VisitValues_builder(ctx *Values_builderContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#other_command. + VisitOther_command(ctx *Other_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#copy_into_table. + VisitCopy_into_table(ctx *Copy_into_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#external_location. + VisitExternal_location(ctx *External_locationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#files. + VisitFiles(ctx *FilesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#file_format. + VisitFile_format(ctx *File_formatContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#format_name. + VisitFormat_name(ctx *Format_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#format_type. + VisitFormat_type(ctx *Format_typeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#stage_file_format. + VisitStage_file_format(ctx *Stage_file_formatContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#copy_into_location. + VisitCopy_into_location(ctx *Copy_into_locationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#comment. + VisitComment(ctx *CommentContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#commit. + VisitCommit(ctx *CommitContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#execute_immediate. + VisitExecute_immediate(ctx *Execute_immediateContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#execute_task. + VisitExecute_task(ctx *Execute_taskContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#explain. + VisitExplain(ctx *ExplainContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#parallel. + VisitParallel(ctx *ParallelContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#get_dml. + VisitGet_dml(ctx *Get_dmlContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#grant_ownership. + VisitGrant_ownership(ctx *Grant_ownershipContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#grant_to_role. + VisitGrant_to_role(ctx *Grant_to_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#global_privileges. + VisitGlobal_privileges(ctx *Global_privilegesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#global_privilege. + VisitGlobal_privilege(ctx *Global_privilegeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#account_object_privileges. + VisitAccount_object_privileges(ctx *Account_object_privilegesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#account_object_privilege. + VisitAccount_object_privilege(ctx *Account_object_privilegeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#schema_privileges. + VisitSchema_privileges(ctx *Schema_privilegesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#schema_privilege. + VisitSchema_privilege(ctx *Schema_privilegeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#schema_object_privileges. + VisitSchema_object_privileges(ctx *Schema_object_privilegesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#schema_object_privilege. + VisitSchema_object_privilege(ctx *Schema_object_privilegeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#grant_to_share. + VisitGrant_to_share(ctx *Grant_to_shareContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_privilege. + VisitObject_privilege(ctx *Object_privilegeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#grant_role. + VisitGrant_role(ctx *Grant_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#role_name. + VisitRole_name(ctx *Role_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#system_defined_role. + VisitSystem_defined_role(ctx *System_defined_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#list. + VisitList(ctx *ListContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#internal_stage. + VisitInternal_stage(ctx *Internal_stageContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#external_stage. + VisitExternal_stage(ctx *External_stageContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#put. + VisitPut(ctx *PutContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#remove. + VisitRemove(ctx *RemoveContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#revoke_from_role. + VisitRevoke_from_role(ctx *Revoke_from_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#revoke_from_share. + VisitRevoke_from_share(ctx *Revoke_from_shareContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#revoke_role. + VisitRevoke_role(ctx *Revoke_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#rollback. + VisitRollback(ctx *RollbackContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#set. + VisitSet(ctx *SetContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#truncate_materialized_view. + VisitTruncate_materialized_view(ctx *Truncate_materialized_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#truncate_table. + VisitTruncate_table(ctx *Truncate_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#unset. + VisitUnset(ctx *UnsetContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_command. + VisitAlter_command(ctx *Alter_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#account_params. + VisitAccount_params(ctx *Account_paramsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_params. + VisitObject_params(ctx *Object_paramsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#default_ddl_collation. + VisitDefault_ddl_collation(ctx *Default_ddl_collationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_properties. + VisitObject_properties(ctx *Object_propertiesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#session_params. + VisitSession_params(ctx *Session_paramsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_account. + VisitAlter_account(ctx *Alter_accountContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#enabled_true_false. + VisitEnabled_true_false(ctx *Enabled_true_falseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_alert. + VisitAlter_alert(ctx *Alter_alertContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#resume_suspend. + VisitResume_suspend(ctx *Resume_suspendContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alert_set_clause. + VisitAlert_set_clause(ctx *Alert_set_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alert_unset_clause. + VisitAlert_unset_clause(ctx *Alert_unset_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_api_integration. + VisitAlter_api_integration(ctx *Alter_api_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#api_integration_property. + VisitApi_integration_property(ctx *Api_integration_propertyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_connection. + VisitAlter_connection(ctx *Alter_connectionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_database. + VisitAlter_database(ctx *Alter_databaseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#database_property. + VisitDatabase_property(ctx *Database_propertyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#account_id_list. + VisitAccount_id_list(ctx *Account_id_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_dynamic_table. + VisitAlter_dynamic_table(ctx *Alter_dynamic_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_external_table. + VisitAlter_external_table(ctx *Alter_external_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#ignore_edition_check. + VisitIgnore_edition_check(ctx *Ignore_edition_checkContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#replication_schedule. + VisitReplication_schedule(ctx *Replication_scheduleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#db_name_list. + VisitDb_name_list(ctx *Db_name_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#share_name_list. + VisitShare_name_list(ctx *Share_name_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#full_acct_list. + VisitFull_acct_list(ctx *Full_acct_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_failover_group. + VisitAlter_failover_group(ctx *Alter_failover_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_file_format. + VisitAlter_file_format(ctx *Alter_file_formatContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_function. + VisitAlter_function(ctx *Alter_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_function_signature. + VisitAlter_function_signature(ctx *Alter_function_signatureContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#data_type_list. + VisitData_type_list(ctx *Data_type_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_masking_policy. + VisitAlter_masking_policy(ctx *Alter_masking_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_materialized_view. + VisitAlter_materialized_view(ctx *Alter_materialized_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_network_policy. + VisitAlter_network_policy(ctx *Alter_network_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_notification_integration. + VisitAlter_notification_integration(ctx *Alter_notification_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_pipe. + VisitAlter_pipe(ctx *Alter_pipeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_procedure. + VisitAlter_procedure(ctx *Alter_procedureContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_replication_group. + VisitAlter_replication_group(ctx *Alter_replication_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#credit_quota. + VisitCredit_quota(ctx *Credit_quotaContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#frequency. + VisitFrequency(ctx *FrequencyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#notify_users. + VisitNotify_users(ctx *Notify_usersContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#triggerDefinition. + VisitTriggerDefinition(ctx *TriggerDefinitionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_resource_monitor. + VisitAlter_resource_monitor(ctx *Alter_resource_monitorContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_role. + VisitAlter_role(ctx *Alter_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_row_access_policy. + VisitAlter_row_access_policy(ctx *Alter_row_access_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_schema. + VisitAlter_schema(ctx *Alter_schemaContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#schema_property. + VisitSchema_property(ctx *Schema_propertyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_security_integration. + VisitAlter_security_integration(ctx *Alter_security_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_security_integration_external_oauth. + VisitAlter_security_integration_external_oauth(ctx *Alter_security_integration_external_oauthContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#security_integration_external_oauth_property. + VisitSecurity_integration_external_oauth_property(ctx *Security_integration_external_oauth_propertyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_security_integration_snowflake_oauth. + VisitAlter_security_integration_snowflake_oauth(ctx *Alter_security_integration_snowflake_oauthContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#security_integration_snowflake_oauth_property. + VisitSecurity_integration_snowflake_oauth_property(ctx *Security_integration_snowflake_oauth_propertyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_security_integration_saml2. + VisitAlter_security_integration_saml2(ctx *Alter_security_integration_saml2Context) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_security_integration_scim. + VisitAlter_security_integration_scim(ctx *Alter_security_integration_scimContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#security_integration_scim_property. + VisitSecurity_integration_scim_property(ctx *Security_integration_scim_propertyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_sequence. + VisitAlter_sequence(ctx *Alter_sequenceContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_session. + VisitAlter_session(ctx *Alter_sessionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_session_policy. + VisitAlter_session_policy(ctx *Alter_session_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_share. + VisitAlter_share(ctx *Alter_shareContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_stage. + VisitAlter_stage(ctx *Alter_stageContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_storage_integration. + VisitAlter_storage_integration(ctx *Alter_storage_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_stream. + VisitAlter_stream(ctx *Alter_streamContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_table. + VisitAlter_table(ctx *Alter_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#clustering_action. + VisitClustering_action(ctx *Clustering_actionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#table_column_action. + VisitTable_column_action(ctx *Table_column_actionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#inline_constraint. + VisitInline_constraint(ctx *Inline_constraintContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#constraint_properties. + VisitConstraint_properties(ctx *Constraint_propertiesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#ext_table_column_action. + VisitExt_table_column_action(ctx *Ext_table_column_actionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#constraint_action. + VisitConstraint_action(ctx *Constraint_actionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#search_optimization_action. + VisitSearch_optimization_action(ctx *Search_optimization_actionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#search_method_with_target. + VisitSearch_method_with_target(ctx *Search_method_with_targetContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_table_alter_column. + VisitAlter_table_alter_column(ctx *Alter_table_alter_columnContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_column_decl_list. + VisitAlter_column_decl_list(ctx *Alter_column_decl_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_column_decl. + VisitAlter_column_decl(ctx *Alter_column_declContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_column_opts. + VisitAlter_column_opts(ctx *Alter_column_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_set_tags. + VisitColumn_set_tags(ctx *Column_set_tagsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_unset_tags. + VisitColumn_unset_tags(ctx *Column_unset_tagsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_tag. + VisitAlter_tag(ctx *Alter_tagContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_task. + VisitAlter_task(ctx *Alter_taskContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_user. + VisitAlter_user(ctx *Alter_userContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_view. + VisitAlter_view(ctx *Alter_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_modify. + VisitAlter_modify(ctx *Alter_modifyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_warehouse. + VisitAlter_warehouse(ctx *Alter_warehouseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_connection_opts. + VisitAlter_connection_opts(ctx *Alter_connection_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_user_opts. + VisitAlter_user_opts(ctx *Alter_user_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_tag_opts. + VisitAlter_tag_opts(ctx *Alter_tag_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_network_policy_opts. + VisitAlter_network_policy_opts(ctx *Alter_network_policy_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_warehouse_opts. + VisitAlter_warehouse_opts(ctx *Alter_warehouse_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alter_account_opts. + VisitAlter_account_opts(ctx *Alter_account_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#set_tags. + VisitSet_tags(ctx *Set_tagsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#tag_decl_list. + VisitTag_decl_list(ctx *Tag_decl_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#unset_tags. + VisitUnset_tags(ctx *Unset_tagsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_command. + VisitCreate_command(ctx *Create_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_account. + VisitCreate_account(ctx *Create_accountContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_alert. + VisitCreate_alert(ctx *Create_alertContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alert_condition. + VisitAlert_condition(ctx *Alert_conditionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alert_action. + VisitAlert_action(ctx *Alert_actionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_api_integration. + VisitCreate_api_integration(ctx *Create_api_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_object_clone. + VisitCreate_object_clone(ctx *Create_object_cloneContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_connection. + VisitCreate_connection(ctx *Create_connectionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_database. + VisitCreate_database(ctx *Create_databaseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_dynamic_table. + VisitCreate_dynamic_table(ctx *Create_dynamic_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#clone_at_before. + VisitClone_at_before(ctx *Clone_at_beforeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#at_before1. + VisitAt_before1(ctx *At_before1Context) interface{} + + // Visit a parse tree produced by SnowflakeParser#header_decl. + VisitHeader_decl(ctx *Header_declContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#compression_type. + VisitCompression_type(ctx *Compression_typeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#compression. + VisitCompression(ctx *CompressionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_external_function. + VisitCreate_external_function(ctx *Create_external_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_external_table. + VisitCreate_external_table(ctx *Create_external_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#external_table_column_decl. + VisitExternal_table_column_decl(ctx *External_table_column_declContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#external_table_column_decl_list. + VisitExternal_table_column_decl_list(ctx *External_table_column_decl_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#full_acct. + VisitFull_acct(ctx *Full_acctContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#integration_type_name. + VisitIntegration_type_name(ctx *Integration_type_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_failover_group. + VisitCreate_failover_group(ctx *Create_failover_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#type_fileformat. + VisitType_fileformat(ctx *Type_fileformatContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_file_format. + VisitCreate_file_format(ctx *Create_file_formatContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#arg_decl. + VisitArg_decl(ctx *Arg_declContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#col_decl. + VisitCol_decl(ctx *Col_declContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#function_definition. + VisitFunction_definition(ctx *Function_definitionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_function. + VisitCreate_function(ctx *Create_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_managed_account. + VisitCreate_managed_account(ctx *Create_managed_accountContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_masking_policy. + VisitCreate_masking_policy(ctx *Create_masking_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#tag_decl. + VisitTag_decl(ctx *Tag_declContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_list_in_parentheses. + VisitColumn_list_in_parentheses(ctx *Column_list_in_parenthesesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_materialized_view. + VisitCreate_materialized_view(ctx *Create_materialized_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_network_policy. + VisitCreate_network_policy(ctx *Create_network_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#cloud_provider_params_auto. + VisitCloud_provider_params_auto(ctx *Cloud_provider_params_autoContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#cloud_provider_params_push. + VisitCloud_provider_params_push(ctx *Cloud_provider_params_pushContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_notification_integration. + VisitCreate_notification_integration(ctx *Create_notification_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_pipe. + VisitCreate_pipe(ctx *Create_pipeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#caller_owner. + VisitCaller_owner(ctx *Caller_ownerContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#executa_as. + VisitExecuta_as(ctx *Executa_asContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#procedure_definition. + VisitProcedure_definition(ctx *Procedure_definitionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_procedure. + VisitCreate_procedure(ctx *Create_procedureContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_replication_group. + VisitCreate_replication_group(ctx *Create_replication_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_resource_monitor. + VisitCreate_resource_monitor(ctx *Create_resource_monitorContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_role. + VisitCreate_role(ctx *Create_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_row_access_policy. + VisitCreate_row_access_policy(ctx *Create_row_access_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_schema. + VisitCreate_schema(ctx *Create_schemaContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_security_integration_external_oauth. + VisitCreate_security_integration_external_oauth(ctx *Create_security_integration_external_oauthContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#implicit_none. + VisitImplicit_none(ctx *Implicit_noneContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_security_integration_snowflake_oauth. + VisitCreate_security_integration_snowflake_oauth(ctx *Create_security_integration_snowflake_oauthContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_security_integration_saml2. + VisitCreate_security_integration_saml2(ctx *Create_security_integration_saml2Context) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_security_integration_scim. + VisitCreate_security_integration_scim(ctx *Create_security_integration_scimContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#network_policy. + VisitNetwork_policy(ctx *Network_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#partner_application. + VisitPartner_application(ctx *Partner_applicationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#start_with. + VisitStart_with(ctx *Start_withContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#increment_by. + VisitIncrement_by(ctx *Increment_byContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_sequence. + VisitCreate_sequence(ctx *Create_sequenceContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_session_policy. + VisitCreate_session_policy(ctx *Create_session_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_share. + VisitCreate_share(ctx *Create_shareContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#character. + VisitCharacter(ctx *CharacterContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#format_type_options. + VisitFormat_type_options(ctx *Format_type_optionsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#copy_options. + VisitCopy_options(ctx *Copy_optionsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#internal_stage_params. + VisitInternal_stage_params(ctx *Internal_stage_paramsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#stage_type. + VisitStage_type(ctx *Stage_typeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#stage_master_key. + VisitStage_master_key(ctx *Stage_master_keyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#stage_kms_key. + VisitStage_kms_key(ctx *Stage_kms_keyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#stage_encryption_opts_aws. + VisitStage_encryption_opts_aws(ctx *Stage_encryption_opts_awsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#aws_token. + VisitAws_token(ctx *Aws_tokenContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#aws_key_id. + VisitAws_key_id(ctx *Aws_key_idContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#aws_secret_key. + VisitAws_secret_key(ctx *Aws_secret_keyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#aws_role. + VisitAws_role(ctx *Aws_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#external_stage_params. + VisitExternal_stage_params(ctx *External_stage_paramsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#true_false. + VisitTrue_false(ctx *True_falseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#enable. + VisitEnable(ctx *EnableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#refresh_on_create. + VisitRefresh_on_create(ctx *Refresh_on_createContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#auto_refresh. + VisitAuto_refresh(ctx *Auto_refreshContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#notification_integration. + VisitNotification_integration(ctx *Notification_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#directory_table_params. + VisitDirectory_table_params(ctx *Directory_table_paramsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_stage. + VisitCreate_stage(ctx *Create_stageContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#cloud_provider_params. + VisitCloud_provider_params(ctx *Cloud_provider_paramsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#cloud_provider_params2. + VisitCloud_provider_params2(ctx *Cloud_provider_params2Context) interface{} + + // Visit a parse tree produced by SnowflakeParser#cloud_provider_params3. + VisitCloud_provider_params3(ctx *Cloud_provider_params3Context) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_storage_integration. + VisitCreate_storage_integration(ctx *Create_storage_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#copy_grants. + VisitCopy_grants(ctx *Copy_grantsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#append_only. + VisitAppend_only(ctx *Append_onlyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#insert_only. + VisitInsert_only(ctx *Insert_onlyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_initial_rows. + VisitShow_initial_rows(ctx *Show_initial_rowsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#stream_time. + VisitStream_time(ctx *Stream_timeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_stream. + VisitCreate_stream(ctx *Create_streamContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#temporary. + VisitTemporary(ctx *TemporaryContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#table_type. + VisitTable_type(ctx *Table_typeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#with_tags. + VisitWith_tags(ctx *With_tagsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#with_row_access_policy. + VisitWith_row_access_policy(ctx *With_row_access_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#cluster_by. + VisitCluster_by(ctx *Cluster_byContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#change_tracking. + VisitChange_tracking(ctx *Change_trackingContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#with_masking_policy. + VisitWith_masking_policy(ctx *With_masking_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#collate. + VisitCollate(ctx *CollateContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#not_null. + VisitNot_null(ctx *Not_nullContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#default_value. + VisitDefault_value(ctx *Default_valueContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#foreign_key. + VisitForeign_key(ctx *Foreign_keyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#out_of_line_constraint. + VisitOut_of_line_constraint(ctx *Out_of_line_constraintContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#full_col_decl. + VisitFull_col_decl(ctx *Full_col_declContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_decl_item. + VisitColumn_decl_item(ctx *Column_decl_itemContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_decl_item_list. + VisitColumn_decl_item_list(ctx *Column_decl_item_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_table. + VisitCreate_table(ctx *Create_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_table_as_select. + VisitCreate_table_as_select(ctx *Create_table_as_selectContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_tag. + VisitCreate_tag(ctx *Create_tagContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#session_parameter. + VisitSession_parameter(ctx *Session_parameterContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#session_parameter_list. + VisitSession_parameter_list(ctx *Session_parameter_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#session_parameter_init_list. + VisitSession_parameter_init_list(ctx *Session_parameter_init_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#session_parameter_init. + VisitSession_parameter_init(ctx *Session_parameter_initContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_task. + VisitCreate_task(ctx *Create_taskContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#sql. + VisitSql(ctx *SqlContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#call. + VisitCall(ctx *CallContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_user. + VisitCreate_user(ctx *Create_userContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#view_col. + VisitView_col(ctx *View_colContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_view. + VisitCreate_view(ctx *Create_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#create_warehouse. + VisitCreate_warehouse(ctx *Create_warehouseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#wh_properties. + VisitWh_properties(ctx *Wh_propertiesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#wh_params. + VisitWh_params(ctx *Wh_paramsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#trigger_definition. + VisitTrigger_definition(ctx *Trigger_definitionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_type_name. + VisitObject_type_name(ctx *Object_type_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_type_plural. + VisitObject_type_plural(ctx *Object_type_pluralContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_command. + VisitDrop_command(ctx *Drop_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_object. + VisitDrop_object(ctx *Drop_objectContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_alert. + VisitDrop_alert(ctx *Drop_alertContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_connection. + VisitDrop_connection(ctx *Drop_connectionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_database. + VisitDrop_database(ctx *Drop_databaseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_dynamic_table. + VisitDrop_dynamic_table(ctx *Drop_dynamic_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_external_table. + VisitDrop_external_table(ctx *Drop_external_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_failover_group. + VisitDrop_failover_group(ctx *Drop_failover_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_file_format. + VisitDrop_file_format(ctx *Drop_file_formatContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_function. + VisitDrop_function(ctx *Drop_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_integration. + VisitDrop_integration(ctx *Drop_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_managed_account. + VisitDrop_managed_account(ctx *Drop_managed_accountContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_masking_policy. + VisitDrop_masking_policy(ctx *Drop_masking_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_materialized_view. + VisitDrop_materialized_view(ctx *Drop_materialized_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_network_policy. + VisitDrop_network_policy(ctx *Drop_network_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_pipe. + VisitDrop_pipe(ctx *Drop_pipeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_procedure. + VisitDrop_procedure(ctx *Drop_procedureContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_replication_group. + VisitDrop_replication_group(ctx *Drop_replication_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_resource_monitor. + VisitDrop_resource_monitor(ctx *Drop_resource_monitorContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_role. + VisitDrop_role(ctx *Drop_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_row_access_policy. + VisitDrop_row_access_policy(ctx *Drop_row_access_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_schema. + VisitDrop_schema(ctx *Drop_schemaContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_sequence. + VisitDrop_sequence(ctx *Drop_sequenceContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_session_policy. + VisitDrop_session_policy(ctx *Drop_session_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_share. + VisitDrop_share(ctx *Drop_shareContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_stage. + VisitDrop_stage(ctx *Drop_stageContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_stream. + VisitDrop_stream(ctx *Drop_streamContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_table. + VisitDrop_table(ctx *Drop_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_tag. + VisitDrop_tag(ctx *Drop_tagContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_task. + VisitDrop_task(ctx *Drop_taskContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_user. + VisitDrop_user(ctx *Drop_userContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_view. + VisitDrop_view(ctx *Drop_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#drop_warehouse. + VisitDrop_warehouse(ctx *Drop_warehouseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#cascade_restrict. + VisitCascade_restrict(ctx *Cascade_restrictContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#arg_types. + VisitArg_types(ctx *Arg_typesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#undrop_command. + VisitUndrop_command(ctx *Undrop_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#undrop_database. + VisitUndrop_database(ctx *Undrop_databaseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#undrop_dynamic_table. + VisitUndrop_dynamic_table(ctx *Undrop_dynamic_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#undrop_schema. + VisitUndrop_schema(ctx *Undrop_schemaContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#undrop_table. + VisitUndrop_table(ctx *Undrop_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#undrop_tag. + VisitUndrop_tag(ctx *Undrop_tagContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#use_command. + VisitUse_command(ctx *Use_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#use_database. + VisitUse_database(ctx *Use_databaseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#use_role. + VisitUse_role(ctx *Use_roleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#use_schema. + VisitUse_schema(ctx *Use_schemaContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#use_secondary_roles. + VisitUse_secondary_roles(ctx *Use_secondary_rolesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#use_warehouse. + VisitUse_warehouse(ctx *Use_warehouseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#comment_clause. + VisitComment_clause(ctx *Comment_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#if_suspended. + VisitIf_suspended(ctx *If_suspendedContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#if_exists. + VisitIf_exists(ctx *If_existsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#if_not_exists. + VisitIf_not_exists(ctx *If_not_existsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#or_replace. + VisitOr_replace(ctx *Or_replaceContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe. + VisitDescribe(ctx *DescribeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_command. + VisitDescribe_command(ctx *Describe_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_alert. + VisitDescribe_alert(ctx *Describe_alertContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_database. + VisitDescribe_database(ctx *Describe_databaseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_dynamic_table. + VisitDescribe_dynamic_table(ctx *Describe_dynamic_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_external_table. + VisitDescribe_external_table(ctx *Describe_external_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_file_format. + VisitDescribe_file_format(ctx *Describe_file_formatContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_function. + VisitDescribe_function(ctx *Describe_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_integration. + VisitDescribe_integration(ctx *Describe_integrationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_masking_policy. + VisitDescribe_masking_policy(ctx *Describe_masking_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_materialized_view. + VisitDescribe_materialized_view(ctx *Describe_materialized_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_network_policy. + VisitDescribe_network_policy(ctx *Describe_network_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_pipe. + VisitDescribe_pipe(ctx *Describe_pipeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_procedure. + VisitDescribe_procedure(ctx *Describe_procedureContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_result. + VisitDescribe_result(ctx *Describe_resultContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_row_access_policy. + VisitDescribe_row_access_policy(ctx *Describe_row_access_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_schema. + VisitDescribe_schema(ctx *Describe_schemaContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_search_optimization. + VisitDescribe_search_optimization(ctx *Describe_search_optimizationContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_sequence. + VisitDescribe_sequence(ctx *Describe_sequenceContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_session_policy. + VisitDescribe_session_policy(ctx *Describe_session_policyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_share. + VisitDescribe_share(ctx *Describe_shareContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_stage. + VisitDescribe_stage(ctx *Describe_stageContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_stream. + VisitDescribe_stream(ctx *Describe_streamContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_table. + VisitDescribe_table(ctx *Describe_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_task. + VisitDescribe_task(ctx *Describe_taskContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_transaction. + VisitDescribe_transaction(ctx *Describe_transactionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_user. + VisitDescribe_user(ctx *Describe_userContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_view. + VisitDescribe_view(ctx *Describe_viewContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#describe_warehouse. + VisitDescribe_warehouse(ctx *Describe_warehouseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_command. + VisitShow_command(ctx *Show_commandContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_alerts. + VisitShow_alerts(ctx *Show_alertsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_columns. + VisitShow_columns(ctx *Show_columnsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_connections. + VisitShow_connections(ctx *Show_connectionsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#starts_with. + VisitStarts_with(ctx *Starts_withContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#limit_rows. + VisitLimit_rows(ctx *Limit_rowsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_databases. + VisitShow_databases(ctx *Show_databasesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_databases_in_failover_group. + VisitShow_databases_in_failover_group(ctx *Show_databases_in_failover_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_databases_in_replication_group. + VisitShow_databases_in_replication_group(ctx *Show_databases_in_replication_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_delegated_authorizations. + VisitShow_delegated_authorizations(ctx *Show_delegated_authorizationsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_external_functions. + VisitShow_external_functions(ctx *Show_external_functionsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_dynamic_tables. + VisitShow_dynamic_tables(ctx *Show_dynamic_tablesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_external_tables. + VisitShow_external_tables(ctx *Show_external_tablesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_failover_groups. + VisitShow_failover_groups(ctx *Show_failover_groupsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_file_formats. + VisitShow_file_formats(ctx *Show_file_formatsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_functions. + VisitShow_functions(ctx *Show_functionsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_global_accounts. + VisitShow_global_accounts(ctx *Show_global_accountsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_grants. + VisitShow_grants(ctx *Show_grantsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_grants_opts. + VisitShow_grants_opts(ctx *Show_grants_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_integrations. + VisitShow_integrations(ctx *Show_integrationsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_locks. + VisitShow_locks(ctx *Show_locksContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_managed_accounts. + VisitShow_managed_accounts(ctx *Show_managed_accountsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_masking_policies. + VisitShow_masking_policies(ctx *Show_masking_policiesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#in_obj. + VisitIn_obj(ctx *In_objContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#in_obj_2. + VisitIn_obj_2(ctx *In_obj_2Context) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_materialized_views. + VisitShow_materialized_views(ctx *Show_materialized_viewsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_network_policies. + VisitShow_network_policies(ctx *Show_network_policiesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_objects. + VisitShow_objects(ctx *Show_objectsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_organization_accounts. + VisitShow_organization_accounts(ctx *Show_organization_accountsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#in_for. + VisitIn_for(ctx *In_forContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_parameters. + VisitShow_parameters(ctx *Show_parametersContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_pipes. + VisitShow_pipes(ctx *Show_pipesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_primary_keys. + VisitShow_primary_keys(ctx *Show_primary_keysContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_procedures. + VisitShow_procedures(ctx *Show_proceduresContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_regions. + VisitShow_regions(ctx *Show_regionsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_replication_accounts. + VisitShow_replication_accounts(ctx *Show_replication_accountsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_replication_databases. + VisitShow_replication_databases(ctx *Show_replication_databasesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_replication_groups. + VisitShow_replication_groups(ctx *Show_replication_groupsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_resource_monitors. + VisitShow_resource_monitors(ctx *Show_resource_monitorsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_roles. + VisitShow_roles(ctx *Show_rolesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_row_access_policies. + VisitShow_row_access_policies(ctx *Show_row_access_policiesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_schemas. + VisitShow_schemas(ctx *Show_schemasContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_sequences. + VisitShow_sequences(ctx *Show_sequencesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_session_policies. + VisitShow_session_policies(ctx *Show_session_policiesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_shares. + VisitShow_shares(ctx *Show_sharesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_shares_in_failover_group. + VisitShow_shares_in_failover_group(ctx *Show_shares_in_failover_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_shares_in_replication_group. + VisitShow_shares_in_replication_group(ctx *Show_shares_in_replication_groupContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_stages. + VisitShow_stages(ctx *Show_stagesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_streams. + VisitShow_streams(ctx *Show_streamsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_tables. + VisitShow_tables(ctx *Show_tablesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_tags. + VisitShow_tags(ctx *Show_tagsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_tasks. + VisitShow_tasks(ctx *Show_tasksContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_transactions. + VisitShow_transactions(ctx *Show_transactionsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_user_functions. + VisitShow_user_functions(ctx *Show_user_functionsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_users. + VisitShow_users(ctx *Show_usersContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_variables. + VisitShow_variables(ctx *Show_variablesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_views. + VisitShow_views(ctx *Show_viewsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#show_warehouses. + VisitShow_warehouses(ctx *Show_warehousesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#like_pattern. + VisitLike_pattern(ctx *Like_patternContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#account_identifier. + VisitAccount_identifier(ctx *Account_identifierContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#schema_name. + VisitSchema_name(ctx *Schema_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_type. + VisitObject_type(ctx *Object_typeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_type_list. + VisitObject_type_list(ctx *Object_type_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#tag_value. + VisitTag_value(ctx *Tag_valueContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#arg_data_type. + VisitArg_data_type(ctx *Arg_data_typeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#arg_name. + VisitArg_name(ctx *Arg_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#param_name. + VisitParam_name(ctx *Param_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#region_group_id. + VisitRegion_group_id(ctx *Region_group_idContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#snowflake_region_id. + VisitSnowflake_region_id(ctx *Snowflake_region_idContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#string. + VisitString(ctx *StringContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#string_list. + VisitString_list(ctx *String_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#id_. + VisitId_(ctx *Id_Context) interface{} + + // Visit a parse tree produced by SnowflakeParser#keyword. + VisitKeyword(ctx *KeywordContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#non_reserved_words. + VisitNon_reserved_words(ctx *Non_reserved_wordsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#builtin_function. + VisitBuiltin_function(ctx *Builtin_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#list_operator. + VisitList_operator(ctx *List_operatorContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#binary_builtin_function. + VisitBinary_builtin_function(ctx *Binary_builtin_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#binary_or_ternary_builtin_function. + VisitBinary_or_ternary_builtin_function(ctx *Binary_or_ternary_builtin_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#ternary_builtin_function. + VisitTernary_builtin_function(ctx *Ternary_builtin_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#pattern. + VisitPattern(ctx *PatternContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_name. + VisitColumn_name(ctx *Column_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_list. + VisitColumn_list(ctx *Column_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_name. + VisitObject_name(ctx *Object_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#num. + VisitNum(ctx *NumContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#expr_list. + VisitExpr_list(ctx *Expr_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#expr_list_sorted. + VisitExpr_list_sorted(ctx *Expr_list_sortedContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#expr. + VisitExpr(ctx *ExprContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#iff_expr. + VisitIff_expr(ctx *Iff_exprContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#trim_expression. + VisitTrim_expression(ctx *Trim_expressionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#try_cast_expr. + VisitTry_cast_expr(ctx *Try_cast_exprContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#json_literal. + VisitJson_literal(ctx *Json_literalContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#kv_pair. + VisitKv_pair(ctx *Kv_pairContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#value. + VisitValue(ctx *ValueContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#arr_literal. + VisitArr_literal(ctx *Arr_literalContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#data_type. + VisitData_type(ctx *Data_typeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#primitive_expression. + VisitPrimitive_expression(ctx *Primitive_expressionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#order_by_expr. + VisitOrder_by_expr(ctx *Order_by_exprContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#asc_desc. + VisitAsc_desc(ctx *Asc_descContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#over_clause. + VisitOver_clause(ctx *Over_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#function_call. + VisitFunction_call(ctx *Function_callContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#ranking_windowed_function. + VisitRanking_windowed_function(ctx *Ranking_windowed_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#aggregate_function. + VisitAggregate_function(ctx *Aggregate_functionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#literal. + VisitLiteral(ctx *LiteralContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#sign. + VisitSign(ctx *SignContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#full_column_name. + VisitFull_column_name(ctx *Full_column_nameContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#bracket_expression. + VisitBracket_expression(ctx *Bracket_expressionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#case_expression. + VisitCase_expression(ctx *Case_expressionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#switch_search_condition_section. + VisitSwitch_search_condition_section(ctx *Switch_search_condition_sectionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#switch_section. + VisitSwitch_section(ctx *Switch_sectionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#query_statement. + VisitQuery_statement(ctx *Query_statementContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#with_expression. + VisitWith_expression(ctx *With_expressionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#common_table_expression. + VisitCommon_table_expression(ctx *Common_table_expressionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#anchor_clause. + VisitAnchor_clause(ctx *Anchor_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#recursive_clause. + VisitRecursive_clause(ctx *Recursive_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#select_statement. + VisitSelect_statement(ctx *Select_statementContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#set_operators. + VisitSet_operators(ctx *Set_operatorsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#select_optional_clauses. + VisitSelect_optional_clauses(ctx *Select_optional_clausesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#select_clause. + VisitSelect_clause(ctx *Select_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#select_top_clause. + VisitSelect_top_clause(ctx *Select_top_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#select_list_no_top. + VisitSelect_list_no_top(ctx *Select_list_no_topContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#select_list_top. + VisitSelect_list_top(ctx *Select_list_topContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#select_list. + VisitSelect_list(ctx *Select_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#select_list_elem. + VisitSelect_list_elem(ctx *Select_list_elemContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_elem. + VisitColumn_elem(ctx *Column_elemContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#as_alias. + VisitAs_alias(ctx *As_aliasContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#expression_elem. + VisitExpression_elem(ctx *Expression_elemContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_position. + VisitColumn_position(ctx *Column_positionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#all_distinct. + VisitAll_distinct(ctx *All_distinctContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#top_clause. + VisitTop_clause(ctx *Top_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#into_clause. + VisitInto_clause(ctx *Into_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#var_list. + VisitVar_list(ctx *Var_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#var. + VisitVar(ctx *VarContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#from_clause. + VisitFrom_clause(ctx *From_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#table_sources. + VisitTable_sources(ctx *Table_sourcesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#table_source. + VisitTable_source(ctx *Table_sourceContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#table_source_item_joined. + VisitTable_source_item_joined(ctx *Table_source_item_joinedContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#object_ref. + VisitObject_ref(ctx *Object_refContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#flatten_table_option. + VisitFlatten_table_option(ctx *Flatten_table_optionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#flatten_table. + VisitFlatten_table(ctx *Flatten_tableContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#prior_list. + VisitPrior_list(ctx *Prior_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#prior_item. + VisitPrior_item(ctx *Prior_itemContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#outer_join. + VisitOuter_join(ctx *Outer_joinContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#join_type. + VisitJoin_type(ctx *Join_typeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#join_clause. + VisitJoin_clause(ctx *Join_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#at_before. + VisitAt_before(ctx *At_beforeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#end. + VisitEnd(ctx *EndContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#changes. + VisitChanges(ctx *ChangesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#default_append_only. + VisitDefault_append_only(ctx *Default_append_onlyContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#partition_by. + VisitPartition_by(ctx *Partition_byContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#alias. + VisitAlias(ctx *AliasContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#expr_alias_list. + VisitExpr_alias_list(ctx *Expr_alias_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#measures. + VisitMeasures(ctx *MeasuresContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#match_opts. + VisitMatch_opts(ctx *Match_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#row_match. + VisitRow_match(ctx *Row_matchContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#first_last. + VisitFirst_last(ctx *First_lastContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#symbol. + VisitSymbol(ctx *SymbolContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#after_match. + VisitAfter_match(ctx *After_matchContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#symbol_list. + VisitSymbol_list(ctx *Symbol_listContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#define. + VisitDefine(ctx *DefineContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#match_recognize. + VisitMatch_recognize(ctx *Match_recognizeContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#pivot_unpivot. + VisitPivot_unpivot(ctx *Pivot_unpivotContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#column_alias_list_in_brackets. + VisitColumn_alias_list_in_brackets(ctx *Column_alias_list_in_bracketsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#expr_list_in_parentheses. + VisitExpr_list_in_parentheses(ctx *Expr_list_in_parenthesesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#values. + VisitValues(ctx *ValuesContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#sample_method. + VisitSample_method(ctx *Sample_methodContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#repeatable_seed. + VisitRepeatable_seed(ctx *Repeatable_seedContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#sample_opts. + VisitSample_opts(ctx *Sample_optsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#sample. + VisitSample(ctx *SampleContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#search_condition. + VisitSearch_condition(ctx *Search_conditionContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#comparison_operator. + VisitComparison_operator(ctx *Comparison_operatorContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#null_not_null. + VisitNull_not_null(ctx *Null_not_nullContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#subquery. + VisitSubquery(ctx *SubqueryContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#predicate. + VisitPredicate(ctx *PredicateContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#where_clause. + VisitWhere_clause(ctx *Where_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#group_item. + VisitGroup_item(ctx *Group_itemContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#group_by_clause. + VisitGroup_by_clause(ctx *Group_by_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#having_clause. + VisitHaving_clause(ctx *Having_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#qualify_clause. + VisitQualify_clause(ctx *Qualify_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#order_item. + VisitOrder_item(ctx *Order_itemContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#order_by_clause. + VisitOrder_by_clause(ctx *Order_by_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#row_rows. + VisitRow_rows(ctx *Row_rowsContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#first_next. + VisitFirst_next(ctx *First_nextContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#limit_clause. + VisitLimit_clause(ctx *Limit_clauseContext) interface{} + + // Visit a parse tree produced by SnowflakeParser#supplement_non_reserved_words. + VisitSupplement_non_reserved_words(ctx *Supplement_non_reserved_wordsContext) interface{} +}